added a way to skip internal contract loading

src/contracts/load-Identity-contracts.ts

@@ -1,88 +1,112 @@
 import type {
   SoulboundCreditScore,
   SoulboundGreen,
-  SoulboundIdentity,
   SoulLinker,
   SoulName,
   SoulStore,
 } from "@masa-finance/masa-contracts-identity";
 import {
   SoulboundCreditScore__factory,
   SoulboundGreen__factory,
+  SoulboundIdentity,
   SoulboundIdentity__factory,
   SoulLinker__factory,
   SoulName__factory,
   SoulStore__factory,
 } from "@masa-finance/masa-contracts-identity";
-import { constants, Signer } from "ethers";
+import { BaseContract, constants, ContractFactory, Signer } from "ethers";
 
 import type { ContractInfo, IIdentityContracts } from "../interface";
 import { NetworkName } from "../interface";
 import { addresses } from "../networks";
 
-export interface LoadContractArgs {
+export interface LoadIdentityContractsArgs {
   signer: Signer;
   networkName?: NetworkName;
+  skipLoadingContracts?: boolean;
 }
 
+const loadContract = <T extends BaseContract & ContractInfo>({
+  factory,
+  address,
+  signer,
+  skipLoadingContracts,
+}: {
+  factory: ContractFactory;
+  address?: string;
+  signer: Signer;
+  skipLoadingContracts?: boolean;
+}): T => {
+  const addr = skipLoadingContracts
+    ? constants.AddressZero
+    : address ?? constants.AddressZero;
+
+  let contract: T = factory.attach(addr) as T;
+
+  contract.hasAddress = Boolean(addr) && addr !== constants.AddressZero;
+
+  if (contract.hasAddress) {
+    contract = { ...contract, ...contract.connect(signer) } as T;
+  }
+  return contract;
+};
+
 export const loadIdentityContracts = ({
   signer,
   networkName = "ethereum",
-}: LoadContractArgs): IIdentityContracts => {
-  const SoulboundIdentityContract: SoulboundIdentity & ContractInfo =
-    SoulboundIdentity__factory.connect(
-      addresses[networkName]?.SoulboundIdentityAddress || constants.AddressZero,
-      signer,
-    );
-  SoulboundIdentityContract.hasAddress = Boolean(
-    addresses[networkName]?.SoulboundIdentityAddress,
-  );
+  skipLoadingContracts,
+}: LoadIdentityContractsArgs): IIdentityContracts => {
+  // Identity
+  const SoulboundIdentityContract = loadContract<
+    SoulboundIdentity & ContractInfo
+  >({
+    factory: new SoulboundIdentity__factory(),
+    address: addresses[networkName]?.SoulboundIdentityAddress,
+    signer,
+    skipLoadingContracts,
+  });
 
-  const SoulboundCreditScoreContract: SoulboundCreditScore & ContractInfo =
-    SoulboundCreditScore__factory.connect(
-      addresses[networkName]?.SoulboundCreditScoreAddress ||
-        constants.AddressZero,
-      signer,
-    );
-  SoulboundCreditScoreContract.hasAddress = Boolean(
-    addresses[networkName]?.SoulboundCreditScoreAddress,
-  );
+  // Credit Score
+  const SoulboundCreditScoreContract = loadContract<
+    SoulboundCreditScore & ContractInfo
+  >({
+    factory: new SoulboundCreditScore__factory(),
+    address: addresses[networkName]?.SoulboundCreditScoreAddress,
+    signer,
+    skipLoadingContracts,
+  });
 
-  const SoulNameContract: SoulName & ContractInfo = SoulName__factory.connect(
-    addresses[networkName]?.SoulNameAddress || constants.AddressZero,
+  // Soul Name
+  const SoulNameContract = loadContract<SoulName & ContractInfo>({
+    factory: new SoulName__factory(),
+    address: addresses[networkName]?.SoulNameAddress,
     signer,
-  );
-  SoulNameContract.hasAddress = Boolean(
-    addresses[networkName]?.SoulNameAddress,
-  );
+    skipLoadingContracts,
+  });
 
-  const SoulLinkerContract: SoulLinker & ContractInfo =
-    SoulLinker__factory.connect(
-      addresses[networkName]?.SoulLinkerAddress || constants.AddressZero,
-      signer,
-    );
-  SoulLinkerContract.hasAddress = Boolean(
-    addresses[networkName]?.SoulLinkerAddress,
-  );
+  // Soul Linker
+  const SoulLinkerContract = loadContract<SoulLinker & ContractInfo>({
+    factory: new SoulLinker__factory(),
+    address: addresses[networkName]?.SoulLinkerAddress,
+    signer,
+    skipLoadingContracts,
+  });
 
-  const SoulStoreContract: SoulStore & ContractInfo =
-    SoulStore__factory.connect(
-      addresses[networkName]?.SoulStoreAddress || constants.AddressZero,
-      signer,
-    );
-  SoulStoreContract.hasAddress = Boolean(
-    addresses[networkName]?.SoulStoreAddress,
-  );
+  // Soul Store
+  const SoulStoreContract = loadContract<SoulStore & ContractInfo>({
+    factory: new SoulStore__factory(),
+    address: addresses[networkName]?.SoulStoreAddress,
+    signer,
+    skipLoadingContracts,
+  });
 
-  const SoulboundGreenContract: SoulboundGreen & ContractInfo =
-    SoulboundGreen__factory.connect(
-      // this might be empty
-      addresses[networkName]?.SoulboundGreenAddress || constants.AddressZero,
-      signer,
-    );
-  SoulboundGreenContract.hasAddress = Boolean(
-    addresses[networkName]?.SoulboundGreenAddress,
-  );
+  // Green
+  const SoulboundGreenContract = loadContract<SoulboundGreen & ContractInfo>({
+    factory: new SoulboundGreen__factory(),
+    address: addresses[networkName]?.SoulboundGreenAddress,
+    signer,
+    skipLoadingContracts,
+  });
 
   return {
     SoulboundIdentityContract,

src/contracts/masa-contracts.ts

@@ -46,16 +46,22 @@ export class MasaContracts extends MasaBase {
    */
   public identity: Identity;
 
-  public constructor(
-    masa: MasaInterface,
-    contractOverrides?: Partial<IIdentityContracts>,
-  ) {
+  public constructor({
+    masa,
+    contractOverrides,
+    skipLoadingContracts = false,
+  }: {
+    masa: MasaInterface;
+    contractOverrides?: Partial<IIdentityContracts>;
+    skipLoadingContracts?: boolean;
+  }) {
     super(masa);
 
     this.instances = {
       ...loadIdentityContracts({
         signer: this.masa.config.signer,
         networkName: this.masa.config.networkName,
+        skipLoadingContracts,
       }),
       ...contractOverrides,
     };

src/interface/masa-args.ts

@@ -7,11 +7,12 @@ import type { NetworkName } from "./network-name";
 
 export interface MasaArgs {
   readonly signer: Signer;
+  readonly networkName?: NetworkName;
   readonly cookie?: string;
   readonly apiUrl?: string;
   readonly environment?: EnvironmentName;
-  readonly networkName?: NetworkName;
-  readonly verbose?: boolean;
   readonly arweave?: ArweaveConfig;
   readonly contractOverrides?: Partial<IIdentityContracts>;
+  readonly skipLoadingContracts?: boolean;
+  readonly verbose?: boolean;
 }

src/masa.ts

@@ -44,6 +44,7 @@ export class Masa implements MasaInterface {
       protocol: "https",
     },
     contractOverrides,
+    skipLoadingContracts = false,
     verbose = false,
   }: MasaArgs) {
     // build config
@@ -67,7 +68,11 @@ export class Masa implements MasaInterface {
     this.arweave = new MasaArweave(arweave, this.config);
 
     // masa contracts wrapper
-    this.contracts = new MasaContracts(this, contractOverrides);
+    this.contracts = new MasaContracts({
+      masa: this,
+      contractOverrides,
+      skipLoadingContracts,
+    });
     // account + session
     this.account = new MasaAccount(this);
     this.session = new MasaSession(this);

src/modules/account/get-balances.ts

@@ -6,7 +6,11 @@ import type {
 } from "@masa-finance/masa-contracts-identity";
 import { constants, utils } from "ethers";
 
-import type { MasaInterface, PaymentMethod } from "../../interface";
+import type {
+  ContractInfo,
+  MasaInterface,
+  PaymentMethod,
+} from "../../interface";
 import type { ERC20 } from "../../stubs";
 import { ERC20__factory } from "../../stubs";
 
@@ -71,12 +75,12 @@ export const getBalances = async (
   };
 
   const loadSBTContractBalance = async (
-    contract: SBTContracts,
+    contract: SBTContracts & ContractInfo,
     addressToLoad: string,
   ): Promise<number | undefined> => {
     let result;
 
-    if (contract.address !== constants.AddressZero) {
+    if (contract.hasAddress) {
       try {
         result = (await contract.balanceOf(addressToLoad)).toNumber();
       } catch (error: unknown) {
@@ -126,7 +130,7 @@ export const getBalances = async (
     : undefined;
 
   const SBTContractBalances: {
-    [key in SBTContractNames]: SBTContracts;
+    [key in SBTContractNames]: SBTContracts & ContractInfo;
   } = {
     Identity: masa.contracts.instances.SoulboundIdentityContract,
     SoulName: masa.contracts.instances.SoulNameContract,