contract v0.0.0

common/method

Functions 

check_all_provisions(
  provisions: List<Provision>,
  transaction: transaction.Transaction,
  treasury_script_hash: Hash<Blake2b_224, credential.Script>,
  stake_addresses: List<credential.StakeCredential>,
) -> Bool

Check, if all provisions has been paid There is minimal price on provision

check_input_scripts(
  inputs: List<transaction.Input>,
  treasury: Credential,
  output_reference: transaction.OutputReference,
) -> Bool

Check, all script input, that there is only treasury and current output reference

check_inputs_contains_tokens(
  context: transaction.ScriptContext,
  policy_id: value.PolicyId,
  number: Int,
) -> Bool

Check, if required amount of asset are present in transaction inputs

check_portions(
  portions: List<types.SellingMarketplaceFeePart>,
  sum: Int,
) -> Bool

Check, if sum of portion is lover then expected

check_required_ada(
  outputs: List<transaction.Output>,
  address: credential.Address,
  amount: Int,
) -> Bool

Check, if output with address exists and contains ADA value

check_required_payment(
  outputs: List<transaction.Output>,
  address: credential.Address,
  wanted_asset: types.WantedAsset,
  ada: Int,
) -> Bool

Check, if ouptut exists and contains ADA/specific asset

check_transaction_is_signed(
  context: transaction.ScriptContext,
  owner: Hash<Blake2b_224, VerificationKey>,
) -> Bool

Check, if transaction is signed by provided payment credential

check_transaction_is_validated(
  context: transaction.ScriptContext,
  datum: types.WithdrawalMethod,
) -> Bool

Check, if trasnsaction is validated by user There is two kinds of validation:

  1. Payment credential
  2. With number of assets with correct PolicyId

check_treasury_address(
  address: Address,
  treasury_script_hash: Hash<Blake2b_224, credential.Script>,
  stake_addresses: List<credential.StakeCredential>,
) -> Bool

Check, if address is valid treasury with correct stakes

check_treasury_input_datum_unique(
  inputs: List<transaction.Input>,
  payment_credential: Credential,
) -> Bool

Check, if treasuries are unique - obsolete

get_number_inputs_ada_by_address_datum(
  inputs: List<transaction.Input>,
  address: Address,
  datum: Data,
) -> (Int, Int)

Get number of inputs and sum ADA by address and datum

get_number_inputs_ada_by_credential_datum(
  inputs: List<transaction.Input>,
  payment_credential: Credential,
  datum: Data,
) -> (Int, Int)

Get number of inputs and sum ADA by script hash and datum

get_number_inputs_by_address_datum(
  inputs: List<transaction.Input>,
  address: Address,
  datum: Data,
) -> Int

Get number of inputs by address and datum

get_number_outputs_ada_by_address_datum_and_check_validity(
  outputs: List<transaction.Output>,
  address: Address,
  datum: Data,
) -> (Int, Int)

Get number of outputs with provided address and script datum There are some required check

  • minimal ADA value
  • no other asset except ADA

get_number_outputs_ada_by_hash_datum_and_check_validity(
  outputs: List<transaction.Output>,
  payment_credential: Credential,
  datum: Data,
) -> (Int, Int)

Get number of outputs and sum of ADA with provided script hash and script datum There are some required check

  • minimal ADA value
  • no other asset except ADA

get_number_outputs_by_address_datum_and_check_validity(
  outputs: List<transaction.Output>,
  address: Address,
  datum: Data,
) -> Int

Get number of outputs with provided address and script datum There are some required check

  • minimal ADA value
  • no other asset except ADA

get_provisions_final_price(
  provisions: List<(types.WithdrawalMethod, Int)>,
  price: Int,
  provision: Int,
  address: Address,
  maybe_royalty: Option<types.Royalty>,
) -> (List<(types.WithdrawalMethod, Int)>, Int)

Mechanism, that allow to pay royalty provision directly (if seller is owner of royalty treasury)

get_script_address(context: transaction.ScriptContext) -> Address

Get script address from context

get_script_hash(context: transaction.ScriptContext) -> Credential

Get script credential from context

get_treasury_input_value(
  inputs: List<transaction.Input>,
  script_hash: Hash<Blake2b_224, credential.Script>,
  stake_addresses: List<credential.StakeCredential>,
  datum: Data,
) -> Int

Get input of specified treasury Treasury must be unique

get_treasury_output_value_and_validate(
  outputs: List<transaction.Output>,
  script_hash: Hash<Blake2b_224, credential.Script>,
  stake_addresses: List<credential.StakeCredential>,
  datum: types.WithdrawalMethod,
) -> Int

Get output of specified treasury Treasury must be unique

policy_id_of(values: value.Value, policy_id: value.PolicyId) -> Int

Gen number of token with PoplicyId - sum all availible

provision_add(
  self: List<Provision>,
  treasury: types.WithdrawalMethod,
  amount: Int,
) -> List<(types.WithdrawalMethod, Int)>

Add provision to list

provision_add_option(
  self: List<Provision>,
  maybe_treasury: Option<types.WithdrawalMethod>,
  amount: Int,
) -> List<(types.WithdrawalMethod, Int)>

provision_add_portion(
  self: List<(types.WithdrawalMethod, Int)>,
  provision_base: Int,
  portions: List<types.SellingMarketplaceFeePart>,
) -> List<(types.WithdrawalMethod, Int)>

Add portion to provision

provision_sum(self: List<(types.WithdrawalMethod, Int)>) -> Int

Sumarize provision

Search Document