Method constructor

packages/cashscript/src/Contract.ts:121–178

* Instantiate a contract from a compiled CashScript artifact. * * @param artifact - The compiled contract artifact produced by `cashc`. * @param constructorArgs - Constructor arguments in the order defined in the contract source. * @param options - Contract options including the network

(
    public artifact: TArtifact,
    constructorArgs: TResolved['constructorInputs'],
    private options: ContractOptions<TContractType>,
  )

   *   compiler version, or if the number or types of constructor arguments does not match the artifact.
   */
  constructor(
    public artifact: TArtifact,
    constructorArgs: TResolved['constructorInputs'],
    private options: ContractOptions<TContractType>,
  ) {
    super();
    this.provider = this.options.provider;

    // Note: technically, it is possible to instantiate a Contract like this, which breaks the type safety,
    // but it seems unreasonable for anyone to do this
    // new Contract<any, any, 'p2s'>(artifact), [], { provider })
    this.contractType = this.options.contractType ?? 'p2sh32' as TContractType;

    const expectedProperties = ['abi', 'bytecode', 'constructorInputs', 'contractName', 'compiler'];
    if (!expectedProperties.every((property) => property in artifact)) {
      throw new Error('Invalid or incomplete artifact provided');
    }

    if (!semver.satisfies(artifact.compiler.version, '>=0.7.0', { includePrerelease: true })) {
      throw new Error(`Artifact compiled with unsupported compiler version: ${artifact.compiler.version}, required >=0.7.0`);
    }

    if (artifact.constructorInputs.length !== constructorArgs.length) {
      throw new Error(`Incorrect number of arguments passed to ${artifact.contractName} constructor. Expected ${artifact.constructorInputs.length} arguments (${artifact.constructorInputs.map((input) => input.type)}) but got ${constructorArgs.length}`);
    }

    // Encode arguments (this also performs type checking)
    this.encodedConstructorArgs = encodeConstructorArguments(artifact, constructorArgs);

    // Populate the 'unlock' object with the contract's functions
    // (with a special case for single function, which has no "function selector")
    this.unlock = {};
    if (artifact.abi.length === 1) {
      const f = artifact.abi[0];
      // @ts-ignore TODO: see if we can use generics to make TypeScript happy
      this.unlock[f.name] = this.createUnlocker(f);
    } else {
      artifact.abi.forEach((f, i) => {
        // @ts-ignore TODO: see if we can use generics to make TypeScript happy
        this.unlock[f.name] = this.createUnlocker(f, i);
      });
    }

    const contractBytecodeScript = generateContractBytecodeScript(
      asmToScript(this.artifact.bytecode), this.encodedConstructorArgs,
    );

    if (this.contractType !== 'p2s') {
      this.address = scriptToAddress(contractBytecodeScript, this.provider.network, this.contractType, false);
      this.tokenAddress = scriptToAddress(contractBytecodeScript, this.provider.network, this.contractType, true);
    }

    this.name = artifact.contractName;
    this.bytecode = binToHex(scriptToBytecode(contractBytecodeScript));
    this.lockingBytecode = this.contractType === 'p2s' ? this.bytecode : binToHex(addressToLockScript(this.address));
    this.bytesize = calculateBytesize(contractBytecodeScript);
    this.opcount = countOpcodes(contractBytecodeScript);
  }