feat: reduce reliance on network package

packages/auth/src/profile.ts

@@ -1,11 +1,11 @@
 import { resolveZoneFileToProfile } from '@stacks/profile';
 import { fetchPrivate } from '@stacks/common';
-import { StacksNetwork, StacksMainnet } from '@stacks/network';
+import { IStacksNetwork, StacksMainnet, StacksNetwork, StacksNetworkName } from '@stacks/network';
 
 export interface ProfileLookupOptions {
   username: string;
   zoneFileLookupURL?: string;
-  network?: StacksNetwork;
+  network?: StacksNetworkName | IStacksNetwork;
 }
 
 /**
@@ -17,11 +17,17 @@ export interface ProfileLookupOptions {
  * blockstack.js [[getNameInfo]] function.
  * @returns {Promise} that resolves to a profile object
  */
-export function lookupProfile(options: ProfileLookupOptions): Promise<Record<string, any>> {
+export function lookupProfile(lookupOptions: ProfileLookupOptions): Promise<Record<string, any>> {
-  if (!options.username) {
+  if (!lookupOptions.username) {
-    return Promise.reject();
+    return Promise.reject(new Error('No username provided'));
   }
-  const network: StacksNetwork = options.network ? options.network : new StacksMainnet();
+
+  const defaultOptions = {
+    network: new StacksMainnet(),
+  };
+  const options = Object.assign(defaultOptions, lookupOptions);
+
+  const network = StacksNetwork.fromNameOrNetwork(options.network);
   let lookupPromise;
   if (options.zoneFileLookupURL) {
     const url = `${options.zoneFileLookupURL.replace(/\/$/, '')}/${options.username}`;

packages/keychain/src/wallet/signer.ts

@@ -11,7 +11,7 @@ import {
   PostCondition,
   AnchorMode,
 } from '@stacks/transactions';
-import { StacksTestnet, StacksNetwork } from '@stacks/network';
+import { StacksTestnet, IStacksNetwork, StacksNetworkName } from '@stacks/network';
 
 import RPCClient from '@blockstack/rpc-client';
 import BN from 'bn.js';
@@ -25,7 +25,7 @@ interface ContractCallOptions {
   nonce: IntegerType;
   postConditions?: PostCondition[];
   postConditionMode?: PostConditionMode;
-  network?: StacksNetwork;
+  network?: StacksNetworkName | IStacksNetwork;
   anchorMode: AnchorMode;
 }
 
@@ -36,7 +36,7 @@ interface ContractDeployOptions {
   nonce: number;
   postConditions?: PostCondition[];
   postConditionMode?: PostConditionMode;
-  network?: StacksNetwork;
+  network?: StacksNetworkName | IStacksNetwork;
   anchorMode: AnchorMode;
 }
 
@@ -47,7 +47,7 @@ interface STXTransferOptions {
   nonce: number;
   postConditions?: PostCondition[];
   postConditionMode?: PostConditionMode;
-  network?: StacksNetwork;
+  network?: StacksNetworkName | IStacksNetwork;
   anchorMode: AnchorMode;
 }
 

packages/network/src/index.ts

@@ -8,7 +8,10 @@ export interface NetworkConfig {
   url: string;
 }
 
-export interface StacksNetwork {
+export const StacksNetworks = ['mainnet', 'testnet'] as const;
+export type StacksNetworkName = typeof StacksNetworks[number];
+
+export interface IStacksNetwork {
   version: TransactionVersion;
   chainId: ChainID;
   bnsLookupUrl: string;
@@ -19,6 +22,7 @@ export interface StacksNetwork {
   accountEndpoint: string;
   contractAbiEndpoint: string;
   readOnlyFunctionCallEndpoint: string;
+
   isMainnet(): boolean;
   getBroadcastApiUrl: () => string;
   getTransferFeeEstimateApiUrl: () => string;
@@ -49,7 +53,7 @@ export interface StacksNetwork {
   getNameInfo: (fullyQualifiedName: string) => any;
 }
 
-export class StacksMainnet implements StacksNetwork {
+export class StacksNetwork implements IStacksNetwork {
   version = TransactionVersion.Mainnet;
   chainId = ChainID.Mainnet;
   bnsLookupUrl = 'https://stacks-node-api.mainnet.stacks.co';
@@ -62,10 +66,35 @@ export class StacksMainnet implements StacksNetwork {
 
   readonly coreApiUrl: string;
 
-  constructor(networkUrl: NetworkConfig = { url: HIRO_MAINNET_DEFAULT }) {
+  constructor(networkConfig: NetworkConfig) {
-    this.coreApiUrl = networkUrl.url;
+    this.coreApiUrl = networkConfig.url;
   }
 
+  static fromName = (networkName: StacksNetworkName): IStacksNetwork => {
+    switch (networkName) {
+      case 'mainnet':
+        return new StacksMainnet();
+      case 'testnet':
+        return new StacksTestnet();
+      default:
+        throw new Error(
+          `Invalid network name provided. Must be one of the following: ${StacksNetworks.join(
+            ', '
+          )}`
+        );
+    }
+  };
+
+  static fromNameOrNetwork = (network: StacksNetworkName | IStacksNetwork) => {
+    if (StacksNetworks.includes(network as StacksNetworkName)) {
+      // network is StacksNetworkName
+      return StacksNetwork.fromName(network as StacksNetworkName);
+    }
+
+    // network is IStacksNetwork
+    return network as IStacksNetwork;
+  };
+
   isMainnet = () => this.version === TransactionVersion.Mainnet;
   getBroadcastApiUrl = () => `${this.coreApiUrl}${this.broadcastEndpoint}`;
   getTransferFeeEstimateApiUrl = () => `${this.coreApiUrl}${this.transferFeeEstimateEndpoint}`;
@@ -133,7 +162,16 @@ export class StacksMainnet implements StacksNetwork {
   }
 }
 
-export class StacksTestnet extends StacksMainnet implements StacksNetwork {
+export class StacksMainnet extends StacksNetwork implements IStacksNetwork {
+  version = TransactionVersion.Mainnet;
+  chainId = ChainID.Mainnet;
+
+  constructor(networkUrl: NetworkConfig = { url: HIRO_MAINNET_DEFAULT }) {
+    super(networkUrl);
+  }
+}
+
+export class StacksTestnet extends StacksNetwork implements IStacksNetwork {
   version = TransactionVersion.Testnet;
   chainId = ChainID.Testnet;
 
@@ -142,7 +180,7 @@ export class StacksTestnet extends StacksMainnet implements StacksNetwork {
   }
 }
 
-export class StacksMocknet extends StacksMainnet implements StacksNetwork {
+export class StacksMocknet extends StacksNetwork implements IStacksNetwork {
   version = TransactionVersion.Testnet;
   chainId = ChainID.Testnet;
 

packages/transactions/src/builders.ts

@@ -1,84 +1,84 @@
-import { Buffer, IntegerType, intToBigInt } from '@stacks/common';
+import { Buffer, fetchPrivate, IntegerType, intToBigInt } from '@stacks/common';
-import { StacksTransaction } from './transaction';
-
-import { StacksNetwork, StacksMainnet, StacksTestnet } from '@stacks/network';
-
 import {
-  createTokenTransferPayload,
+  IStacksNetwork,
-  createSmartContractPayload,
+  StacksMainnet,
-  createContractCallPayload,
+  StacksNetwork,
-  serializePayload,
+  StacksNetworkName,
-  Payload,
+  StacksTestnet,
-} from './payload';
+} from '@stacks/network';
-
+import { c32address } from 'c32check';
 import {
-  createSingleSigSpendingCondition,
   createMultiSigSpendingCondition,
+  createSingleSigSpendingCondition,
   createSponsoredAuth,
   createStandardAuth,
 } from './authorization';
-
+import { ClarityValue, PrincipalCV } from './clarity';
-import {
-  publicKeyToString,
-  createStacksPrivateKey,
-  getPublicKey,
-  publicKeyToAddress,
-  pubKeyfromPrivKey,
-  publicKeyFromBuffer,
-  createStacksPublicKey,
-} from './keys';
-
-import { TransactionSigner } from './signer';
-
-import {
-  createSTXPostCondition,
-  createFungiblePostCondition,
-  createNonFungiblePostCondition,
-} from './postcondition';
-import {
-  PostCondition,
-  STXPostCondition,
-  FungiblePostCondition,
-  NonFungiblePostCondition,
-} from './postcondition-types';
-
 import {
   AddressHashMode,
   AddressVersion,
+  AnchorMode,
   FungibleConditionCode,
   NonFungibleConditionCode,
-  PostConditionMode,
   PayloadType,
-  AnchorMode,
+  PostConditionMode,
+  SingleSigHashMode,
   TransactionVersion,
   TxRejectedReason,
-  SingleSigHashMode,
 } from './constants';
-
+import { ClarityAbi, validateContractCall } from './contract-abi';
+import {
+  createStacksPrivateKey,
+  createStacksPublicKey,
+  getPublicKey,
+  pubKeyfromPrivKey,
+  publicKeyFromBuffer,
+  publicKeyToAddress,
+  publicKeyToString,
+} from './keys';
+import {
+  createContractCallPayload,
+  createSmartContractPayload,
+  createTokenTransferPayload,
+  Payload,
+  serializePayload,
+} from './payload';
+import {
+  createFungiblePostCondition,
+  createNonFungiblePostCondition,
+  createSTXPostCondition,
+} from './postcondition';
+import {
+  AssetInfo,
+  createContractPrincipal,
+  createStandardPrincipal,
+  FungiblePostCondition,
+  NonFungiblePostCondition,
+  PostCondition,
+  STXPostCondition,
+} from './postcondition-types';
+import { TransactionSigner } from './signer';
+import { StacksTransaction } from './transaction';
 import { createLPList } from './types';
-import { AssetInfo, createStandardPrincipal, createContractPrincipal } from './postcondition-types';
+import { cvToHex, omit, parseReadOnlyResponse, validateTxId } from './utils';
-
-import { cvToHex, parseReadOnlyResponse, omit, validateTxId } from './utils';
-
-import { fetchPrivate } from '@stacks/common';
-
-import { ClarityValue, PrincipalCV } from './clarity';
-import { validateContractCall, ClarityAbi } from './contract-abi';
-import { c32address } from 'c32check';
 
 /**
  * Lookup the nonce for an address from a core node
  *
  * @param {string} address - the c32check address to look up
- * @param {StacksNetwork} network - the Stacks network to look up address on
+ * @param {StacksNetworkName | IStacksNetwork} network - the Stacks network to look up address on
  *
  * @return a promise that resolves to an integer
  */
-export async function getNonce(address: string, network?: StacksNetwork): Promise<bigint> {
+export async function getNonce(
+  address: string,
+  network?: StacksNetworkName | IStacksNetwork
+): Promise<bigint> {
   const defaultNetwork = new StacksMainnet();
   const url = network
-    ? network.getAccountApiUrl(address)
+    ? StacksNetwork.fromNameOrNetwork(network).getAccountApiUrl(address)
     : defaultNetwork.getAccountApiUrl(address);
+
   const response = await fetchPrivate(url);
   if (!response.ok) {
     let msg = '';
@@ -100,13 +100,13 @@ export async function getNonce(address: string, network?: StacksNetwork): Promis
  * Estimate the total transaction fee in microstacks for a token transfer
  *
  * @param {StacksTransaction} transaction - the token transfer transaction to estimate fees for
- * @param {StacksNetwork} network - the Stacks network to estimate transaction for
+ * @param {StacksNetworkName | IStacksNetwork} network - the Stacks network to estimate transaction for
  *
  * @return a promise that resolves to number of microstacks per byte
  */
 export async function estimateTransfer(
   transaction: StacksTransaction,
-  network?: StacksNetwork
+  network?: StacksNetworkName | IStacksNetwork
 ): Promise<bigint> {
   if (transaction.payload.payloadType !== PayloadType.TokenTransfer) {
     throw new Error(
@@ -125,10 +125,9 @@ export async function estimateTransfer(
     headers: requestHeaders,
   };
 
-  const defaultNetwork = new StacksMainnet();
+  const derivedNetwork = network ?? deriveNetwork(transaction);
-  const url = network
+  const url = StacksNetwork.fromNameOrNetwork(derivedNetwork).getTransferFeeEstimateApiUrl();
-    ? network.getTransferFeeEstimateApiUrl()
+
-    : defaultNetwork.getTransferFeeEstimateApiUrl();
   const response = await fetchPrivate(url, fetchOptions);
   if (!response.ok) {
     let msg = '';
@@ -169,14 +168,14 @@ interface FeeEstimateResponse {
  * @param {number} estimatedLen - is an optional argument that provides the endpoint with an
  * estimation of the final length (in bytes) of the transaction, including any post-conditions
  * and signatures
- * @param {StacksNetwork} network - the Stacks network to estimate transaction fees for
+ * @param {StacksNetworkName | IStacksNetwork} network - the Stacks network to estimate transaction fees for
  *
  * @return a promise that resolves to FeeEstimate
  */
 export async function estimateTransaction(
   transactionPayload: Payload,
   estimatedLen?: number,
-  network?: StacksNetwork
+  network?: StacksNetworkName | IStacksNetwork
 ): Promise<[FeeEstimation, FeeEstimation, FeeEstimation]> {
   const options = {
     method: 'POST',
@@ -188,9 +187,8 @@ export async function estimateTransaction(
   };
 
   const defaultNetwork = new StacksMainnet();
-
   const url = network
-    ? network.getTransactionFeeEstimateApiUrl()
+    ? StacksNetwork.fromNameOrNetwork(network).getTransactionFeeEstimateApiUrl()
     : defaultNetwork.getTransactionFeeEstimateApiUrl();
 
   const response = await fetchPrivate(url, options);
@@ -393,17 +391,18 @@ export type TxBroadcastResult = TxBroadcastResultOk | TxBroadcastResultRejected;
  * Broadcast the signed transaction to a core node
  *
  * @param {StacksTransaction} transaction - the token transfer transaction to broadcast
- * @param {StacksNetwork} network - the Stacks network to broadcast transaction to
+ * @param {StacksNetworkName | IStacksNetwork} network - the Stacks network to broadcast transaction to
  *
  * @returns {Promise} that resolves to a response if the operation succeeds
  */
 export async function broadcastTransaction(
   transaction: StacksTransaction,
-  network: StacksNetwork,
+  network?: StacksNetworkName | IStacksNetwork,
   attachment?: Buffer
 ): Promise<TxBroadcastResult> {
   const rawTx = transaction.serialize();
-  const url = network.getBroadcastApiUrl();
+  const derivedNetwork = network ?? deriveNetwork(transaction);
+  const url = StacksNetwork.fromNameOrNetwork(derivedNetwork).getBroadcastApiUrl();
 
   return broadcastRawTransaction(rawTx, url, attachment);
 }
@@ -459,20 +458,20 @@ export async function broadcastRawTransaction(
  *
  * @param {string} address - the contracts address
  * @param {string} contractName - the contracts name
- * @param {StacksNetwork} network - the Stacks network to broadcast transaction to
+ * @param {StacksNetworkName | IStacksNetwork} network - the Stacks network to broadcast transaction to
  *
  * @returns {Promise} that resolves to a ClarityAbi if the operation succeeds
  */
 export async function getAbi(
   address: string,
   contractName: string,
-  network: StacksNetwork
+  network: StacksNetworkName | IStacksNetwork
 ): Promise<ClarityAbi> {
   const options = {
     method: 'GET',
   };
 
-  const url = network.getAbiApiUrl(address, contractName);
+  const url = StacksNetwork.fromNameOrNetwork(network).getAbiApiUrl(address, contractName);
 
   const response = await fetchPrivate(url, options);
   if (!response.ok) {
@@ -488,6 +487,15 @@ export async function getAbi(
   return JSON.parse(await response.text()) as ClarityAbi;
 }
 
+function deriveNetwork(transaction: StacksTransaction) {
+  switch (transaction.version) {
+    case TransactionVersion.Mainnet:
+      return new StacksMainnet();
+    case TransactionVersion.Testnet:
+      return new StacksTestnet();
+  }
+}
+
 export interface MultiSigOptions {
   numSignatures: number;
   publicKeys: string[];
@@ -507,7 +515,7 @@ export interface TokenTransferOptions {
   /** the transaction nonce, which must be increased monotonically with each new transaction */
   nonce?: IntegerType;
   /** the network that the transaction will ultimately be broadcast to */
-  network?: StacksNetwork;
+  network?: StacksNetworkName | IStacksNetwork;
   /** the transaction anchorMode, which specifies whether it should be
    * included in an anchor block or a microblock */
   anchorMode: AnchorMode;
@@ -548,7 +556,7 @@ export interface SignedMultiSigTokenTransferOptions extends TokenTransferOptions
  *
  * @param  {UnsignedTokenTransferOptions | UnsignedMultiSigTokenTransferOptions} txOptions - an options object for the token transfer
  *
- * @return {Promis<StacksTransaction>}
+ * @return {Promise<StacksTransaction>}
  */
 export async function makeUnsignedSTXTokenTransfer(
   txOptions: UnsignedTokenTransferOptions | UnsignedMultiSigTokenTransferOptions
@@ -594,22 +602,24 @@ export async function makeUnsignedSTXTokenTransfer(
     authorization = createStandardAuth(spendingCondition);
   }
 
+  const network = StacksNetwork.fromNameOrNetwork(options.network);
+
   const postConditions: PostCondition[] = [];
   if (options.postConditions && options.postConditions.length > 0) {
     options.postConditions.forEach(postCondition => {
       postConditions.push(postCondition);
     });
   }
-
   const lpPostConditions = createLPList(postConditions);
+
   const transaction = new StacksTransaction(
-    options.network.version,
+    network.version,
     authorization,
     payload,
     lpPostConditions,
     options.postConditionMode,
     options.anchorMode,
-    options.network.chainId
+    network.chainId
   );
 
   if (txOptions.fee === undefined || txOptions.fee === null) {
@@ -685,7 +695,7 @@ export interface BaseContractDeployOptions {
   /** the transaction nonce, which must be increased monotonically with each new transaction */
   nonce?: IntegerType;
   /** the network that the transaction will ultimately be broadcast to */
-  network?: StacksNetwork;
+  network?: StacksNetworkName | IStacksNetwork;
   /** the transaction anchorMode, which specifies whether it should be
    * included in an anchor block or a microblock */
   anchorMode: AnchorMode;
@@ -714,13 +724,13 @@ export interface UnsignedContractDeployOptions extends BaseContractDeployOptions
  * Estimate the total transaction fee in microstacks for a contract deploy
  *
  * @param {StacksTransaction} transaction - the token transfer transaction to estimate fees for
- * @param {StacksNetwork} network - the Stacks network to estimate transaction for
+ * @param {StacksNetworkName | IStacksNetwork} network - the Stacks network to estimate transaction for
  *
  * @return a promise that resolves to number of microstacks per byte
  */
 export async function estimateContractDeploy(
   transaction: StacksTransaction,
-  network?: StacksNetwork
+  network?: StacksNetworkName | IStacksNetwork
 ): Promise<bigint> {
   if (transaction.payload.payloadType !== PayloadType.SmartContract) {
     throw new Error(
@@ -741,10 +751,8 @@ export async function estimateContractDeploy(
 
   // Place holder estimate until contract deploy fee estimation is fully implemented on Stacks
   // blockchain core
-  const defaultNetwork = new StacksMainnet();
+  const derivedNetwork = network ?? deriveNetwork(transaction);
-  const url = network
+  const url = StacksNetwork.fromNameOrNetwork(derivedNetwork).getTransferFeeEstimateApiUrl();
-    ? network.getTransferFeeEstimateApiUrl()
-    : defaultNetwork.getTransferFeeEstimateApiUrl();
 
   const response = await fetchPrivate(url, fetchOptions);
   if (!response.ok) {
@@ -821,22 +829,24 @@ export async function makeUnsignedContractDeploy(
     authorization = createStandardAuth(spendingCondition);
   }
 
+  const network = StacksNetwork.fromNameOrNetwork(options.network);
+
   const postConditions: PostCondition[] = [];
   if (options.postConditions && options.postConditions.length > 0) {
     options.postConditions.forEach(postCondition => {
       postConditions.push(postCondition);
     });
   }
-
   const lpPostConditions = createLPList(postConditions);
+
   const transaction = new StacksTransaction(
-    options.network.version,
+    network.version,
     authorization,
     payload,
     lpPostConditions,
     options.postConditionMode,
     options.anchorMode,
-    options.network.chainId
+    network.chainId
   );
 
   if (txOptions.fee === undefined || txOptions.fee === null) {
@@ -873,7 +883,7 @@ export interface ContractCallOptions {
   /** the transaction nonce, which must be increased monotonically with each new transaction */
   nonce?: IntegerType;
   /** the Stacks blockchain network that will ultimately be used to broadcast this transaction */
-  network?: StacksNetwork;
+  network?: StacksNetworkName | IStacksNetwork;
   /** the transaction anchorMode, which specifies whether it should be
    * included in an anchor block or a microblock */
   anchorMode: AnchorMode;
@@ -914,13 +924,13 @@ export interface SignedMultiSigContractCallOptions extends ContractCallOptions {
  * Estimate the total transaction fee in microstacks for a contract function call
  *
  * @param {StacksTransaction} transaction - the token transfer transaction to estimate fees for
- * @param {StacksNetwork} network - the Stacks network to estimate transaction for
+ * @param {StacksNetworkName | IStacksNetwork} network - the Stacks network to estimate transaction for
  *
  * @return a promise that resolves to number of microstacks per byte
  */
 export async function estimateContractFunctionCall(
   transaction: StacksTransaction,
-  network?: StacksNetwork
+  network?: StacksNetworkName | IStacksNetwork
 ): Promise<bigint> {
   if (transaction.payload.payloadType !== PayloadType.ContractCall) {
     throw new Error(
@@ -941,10 +951,8 @@ export async function estimateContractFunctionCall(
 
   // Place holder estimate until contract call fee estimation is fully implemented on Stacks
   // blockchain core
-  const defaultNetwork = new StacksMainnet();
+  const derivedNetwork = network ?? deriveNetwork(transaction);
-  const url = network
+  const url = StacksNetwork.fromNameOrNetwork(derivedNetwork).getTransferFeeEstimateApiUrl();
-    ? network.getTransferFeeEstimateApiUrl()
-    : defaultNetwork.getTransferFeeEstimateApiUrl();
 
   const response = await fetchPrivate(url, fetchOptions);
   if (!response.ok) {
@@ -1032,6 +1040,8 @@ export async function makeUnsignedContractCall(
     authorization = createStandardAuth(spendingCondition);
   }
 
+  const network = StacksNetwork.fromNameOrNetwork(options.network);
+
   const postConditions: PostCondition[] = [];
   if (options.postConditions && options.postConditions.length > 0) {
     options.postConditions.forEach(postCondition => {
@@ -1041,28 +1051,28 @@ export async function makeUnsignedContractCall(
 
   const lpPostConditions = createLPList(postConditions);
   const transaction = new StacksTransaction(
-    options.network.version,
+    network.version,
     authorization,
     payload,
     lpPostConditions,
     options.postConditionMode,
     options.anchorMode,
-    options.network.chainId
+    network.chainId
   );
 
   if (txOptions.fee === undefined || txOptions.fee === null) {
     const estimatedLen = transaction.serialize().byteLength;
-    const txFee = await estimateTransaction(payload, estimatedLen, options.network);
+    const txFee = await estimateTransaction(payload, estimatedLen, network);
     transaction.setFee(txFee[1].fee);
   }
 
   if (txOptions.nonce === undefined || txOptions.nonce === null) {
     const addressVersion =
-      options.network.version === TransactionVersion.Mainnet
+      network.version === TransactionVersion.Mainnet
         ? AddressVersion.MainnetSingleSig
         : AddressVersion.TestnetSingleSig;
     const senderAddress = c32address(addressVersion, transaction.auth.spendingCondition!.signer);
-    const txNonce = await getNonce(senderAddress, options.network);
+    const txNonce = await getNonce(senderAddress, network);
     transaction.setNonce(txNonce);
   }
 
@@ -1264,7 +1274,7 @@ export function makeContractNonFungiblePostCondition(
  * @param  {String} contractName - the contract name
  * @param  {String} functionName - name of the function to be called
  * @param  {[ClarityValue]} functionArgs - an array of Clarity values as arguments to the function call
- * @param  {StacksNetwork} network - the Stacks blockchain network this transaction is destined for
+ * @param  {IStacksNetwork} network - the Stacks blockchain network this transaction is destined for
  * @param  {String} senderAddress - the c32check address of the sender
  */
 
@@ -1274,7 +1284,7 @@ export interface ReadOnlyFunctionOptions {
   functionName: string;
   functionArgs: ClarityValue[];
   /** the network that the contract which contains the function is deployed to */
-  network?: StacksNetwork;
+  network?: StacksNetworkName | IStacksNetwork;
   /** address of the sender */
   senderAddress: string;
 }
@@ -1297,9 +1307,9 @@ export async function callReadOnlyFunction(
 
   const options = Object.assign(defaultOptions, readOnlyFunctionOptions);
 
-  const { contractName, contractAddress, functionName, functionArgs, network, senderAddress } =
+  const { contractName, contractAddress, functionName, functionArgs, senderAddress } = options;
-    options;
 
+  const network = StacksNetwork.fromNameOrNetwork(options.network);
   const url = network.getReadOnlyFunctionCallApiUrl(contractAddress, contractName, functionName);
 
   const args = functionArgs.map(arg => cvToHex(arg));
@@ -1345,7 +1355,7 @@ export interface SponsorOptionsOpts {
   /** the hashmode of the sponsor's address */
   sponsorAddressHashmode?: AddressHashMode;
   /** the Stacks blockchain network that this transaction will ultimately be broadcast to */
-  network?: StacksNetwork;
+  network?: StacksNetworkName | IStacksNetwork;
 }
 
 /**
@@ -1364,14 +1374,15 @@ export async function sponsorTransaction(
     fee: 0 as IntegerType,
     sponsorNonce: 0 as IntegerType,
     sponsorAddressHashmode: AddressHashMode.SerializeP2PKH as SingleSigHashMode,
+    network:
+      sponsorOptions.transaction.version === TransactionVersion.Mainnet
+        ? new StacksMainnet()
+        : new StacksTestnet(),
   };
 
   const options = Object.assign(defaultOptions, sponsorOptions);
-  const network =
+
-    sponsorOptions.network ??
+  const network = StacksNetwork.fromNameOrNetwork(options.network);
-    (options.transaction.version === TransactionVersion.Mainnet
-      ? new StacksMainnet()
-      : new StacksTestnet());
   const sponsorPubKey = pubKeyfromPrivKey(options.sponsorPrivateKey);
 
   if (sponsorOptions.fee === undefined || sponsorOptions.fee === null) {

packages/transactions/tests/builder.test.ts

@@ -20,7 +20,8 @@ import {
   sponsorTransaction,
   makeSTXTokenTransfer,
   makeUnsignedContractCall,
-  estimateTransaction
+  estimateTransaction,
+  SignedTokenTransferOptions
 } from '../src/builders';
 
 import { deserializeTransaction, StacksTransaction } from '../src/transaction';