docs: def create(self, did, service_definition_id, agreement_id,
                 service_agreement_signature, consumer_address, account):
          """
          Execute the service agreement on-chain using keeper's ServiceAgreement contract.
  
          The on-chain executeAgreement method requires the following arguments:
          templateId, signature, consumer, hashes, timeouts, serviceAgreementId, did.
          `agreement_message_hash` is necessary to verify the signature.
          The consumer `signature` includes the conditions timeouts and parameters values which
          is usedon-chain to verify that the values actually match the signed hashes.
  
          :param did: str representation fo the asset DID. Use this to retrieve the asset DDO.
          :param service_definition_id: str identifies the specific service in
           the ddo to use in this agreement.
          :param agreement_id: 32 bytes identifier created by the consumer and will be used
           on-chain for the executed agreement.
          :param service_agreement_signature: str the signed agreement message hash which includes
           conditions and their parameters values and other details of the agreement.
          :param consumer_address: ethereum account address of consumer, hex str
          :param account: Account instance creating the agreement. Can be either the
              consumer, publisher or provider
          :return: dict the `executeAgreement` transaction receipt
          """
          assert consumer_address and Web3Provider.get_web3().isChecksumAddress(
              consumer_address), f'Invalid consumer address {consumer_address}'
          assert account.address in self._keeper.accounts, \
              f'Unrecognized account address {account.address}'
  
          agreement_template_approved = self._keeper.template_manager.is_template_approved(
              self._keeper.escrow_access_secretstore_template.address)
          if not agreement_template_approved:
              msg = (f'The EscrowAccessSecretStoreTemplate contract at address '
                     f'{self._keeper.escrow_access_secretstore_template.address} is not '
                     f'approved and cannot be used for creating service agreements.')
              logger.warning(msg)
              raise OceanInvalidAgreementTemplate(msg)
  
          asset = self._asset_resolver.resolve(did)
          asset_id = asset.asset_id
          service_agreement = ServiceAgreement.from_ddo(service_definition_id, asset)
          agreement_template = self._keeper.escrow_access_secretstore_template
  
          if agreement_template.get_agreement_consumer(agreement_id) is not None:
              raise OceanServiceAgreementExists(
                  f'Service agreement {agreement_id} already exists, cannot reuse '
                  f'the same agreement id.')
  
          if consumer_address != account.address:
              if not self._verify_service_agreement_signature(
                      did, agreement_id, service_definition_id,
                      consumer_address, service_agreement_signature,
                      ddo=asset
              ):
                  raise OceanInvalidServiceAgreementSignature(
                      f'Verifying consumer signature failed: '
                      f'signature {service_agreement_signature}, '
                      f'consumerAddress {consumer_address}'
                  )
  
          publisher_address = Web3Provider.get_web3().toChecksumAddress(asset.publisher)
          condition_ids = service_agreement.generate_agreement_condition_ids(
              agreement_id, asset_id, consumer_address, publisher_address, self._keeper)
  
          time_locks = service_agreement.conditions_timelocks
          time_outs = service_agreement.conditions_timeouts
          success = agreement_template.create_agreement(
              agreement_id,
              asset_id,
              condition_ids,
              time_locks,
              time_outs,
              consumer_address,
              account
          )
  
          if not success:
              # success is based on tx receipt which is not reliable.
              # So we check on-chain directly to see if agreement_id is there
              consumer = self._keeper.escrow_access_secretstore_template.get_agreement_consumer(agreement_id)
              if consumer:
                  success = True
              else:
                  event_log = self._keeper.escrow_access_secretstore_template.subscribe_agreement_created(
                      agreement_id, 30, None, (), wait=True
                  )
                  success = event_log is not None
  
          if success:
              logger.info(f'Service agreement {agreement_id} created successfully.')
          else:
              logger.info(f'Create agreement "{agreement_id}" failed.')
              self._log_agreement_info(
                  asset, service_agreement, agreement_id, service_agreement_signature,
                  consumer_address, account, condition_ids
              )
  
          if success:
              # subscribe to events related to this agreement_id
              if consumer_address == account.address:
                  register_service_agreement_consumer(
                      self._config.storage_path,
                      publisher_address,
                      agreement_id,
                      did,
                      service_agreement,
                      service_definition_id,
                      service_agreement.get_price(),
                      asset.encrypted_files,
                      account,
                      condition_ids,
                      None
                  )
  
              else:
                  register_service_agreement_publisher(
                      self._config.storage_path,
                      consumer_address,
                      agreement_id,
                      did,
                      service_agreement,
                      service_definition_id,
                      service_agreement.get_price(),
                      account,
                      condition_ids
                  )
  
          return success