gistfile1.txt

import Safe, {
  ContractNetworkConfig,
  ContractNetworksConfig,
  SafeAccountConfig,
  SafeFactoryConfig,
  SafeProvider
} from "@safe-global/protocol-kit";
import { SafeConfigWithPredictedSafe } from "@safe-global/protocol-kit/dist/src/types/safeConfig";
import { SafeConfig } from "@safe-global/protocol-kit/dist/src/types";
import { SafeVersion } from "@safe-global/safe-core-sdk-types";
import {
  getCompatibilityFallbackHandlerContractInstance,
  getCreateCallContractInstance,
  getMultiSendCallOnlyContractInstance,
  getMultiSendContractInstance,
  getSafeContractInstance,
  getSafeProxyFactoryContractInstance,
  getSafeWebAuthnSharedSignerContractInstance,
  getSafeWebAuthnSignerFactoryContractInstance,
  getSignMessageLibContractInstance,
  getSimulateTxAccessorContractInstance
} from "@safe-global/protocol-kit/dist/src/contracts/contractInstances";

private async getContractNetworksConfigFromSDK(chainId: bigint): Promise<ContractNetworkConfig | undefined> {
  try {
    const safeVersion: SafeVersion = "1.4.1";
const safeProvider: SafeProvider = new SafeProvider({
  provider: this.rpcProvider,
  signer: this.walletPrivateKey
});

const safeContract = await getSafeContractInstance(safeVersion, safeProvider);
const fallbackHandlerContract = await getCompatibilityFallbackHandlerContractInstance(safeVersion, safeProvider);
const multiSendContract = await getMultiSendContractInstance(safeVersion, safeProvider);
const multiSendCallOnlyContract = await getMultiSendCallOnlyContractInstance(safeVersion, safeProvider);
const safeProxyFactoryContract = await getSafeProxyFactoryContractInstance(
  safeVersion,
  safeProvider,
  this.rpcProvider
);
const signMessageLibContract = await getSignMessageLibContractInstance(safeVersion, safeProvider);
const createCallContract = await getCreateCallContractInstance(safeVersion, safeProvider);
const simulateTxAccessorContract = await getSimulateTxAccessorContractInstance(safeVersion, safeProvider);
const safeWebAuthnSignerFactoryContract = await getSafeWebAuthnSignerFactoryContractInstance(
  safeVersion,
  safeProvider
);
const safeWebAuthnSharedSignerContract = await getSafeWebAuthnSharedSignerContractInstance(
  safeVersion,
  safeProvider
);

const contractNetworkConfig: ContractNetworkConfig = {
  safeSingletonAddress: await safeContract.getAddress(),
  safeProxyFactoryAddress: await safeProxyFactoryContract.getAddress(),
  multiSendAddress: await multiSendContract.getAddress(),
  multiSendCallOnlyAddress: await multiSendCallOnlyContract.getAddress(),
  fallbackHandlerAddress: await fallbackHandlerContract.getAddress(),
  createCallAddress: await createCallContract.getAddress(),
  signMessageLibAddress: await signMessageLibContract.getAddress(),
  simulateTxAccessorAddress: await simulateTxAccessorContract.getAddress(),
  safeWebAuthnSignerFactoryAddress: await safeWebAuthnSignerFactoryContract.getAddress(),
  safeWebAuthnSharedSignerAddress: await safeWebAuthnSharedSignerContract.getAddress()
};

const criticalKeys: (keyof ContractNetworkConfig)[] = [
  "safeSingletonAddress",
  "safeProxyFactoryAddress",
  "multiSendAddress",
  "fallbackHandlerAddress",
  "createCallAddress",
  "signMessageLibAddress",
  "simulateTxAccessorAddress"
];

let allCriticalKeysPresent = true;
criticalKeys.forEach(key => {
  if (!contractNetworkConfig[key]) {
    this.logger.warn(`Critical contract address ${key} could not be retrieved from Safe SDK.`);
    allCriticalKeysPresent = false;
  }
});

if (!allCriticalKeysPresent) {
  this.logger.warn(`Incomplete ContractNetworkConfig obtained from Safe SDK for chainId ${chainId}.`);
  return undefined;
}

return contractNetworkConfig;
} catch (error) {
  this.logger.error("Error while fetching ContractNetworkConfig from Safe SDK methods.", error);
  return undefined;
}
}