vodka 0.1.21

cocktail/vodka_inputs

Functions 

input_inline_datum(input: Input) -> Data

Extracts the inline datum from an input.

expect inline_datum: MyDatumType = input_inline_datum(input)


only_input_datum_with(
  inputs: List<Input>,
  policy: PolicyId,
  name: AssetName,
) -> Data

Extract the inline datum by locating the first input in a list of inputs by Address and PolicyId.

expect inline_datum: MyDatumType = only_input_datum_with(inputs, policy, name)


inputs_at(inputs: List<Input>, address: Address) -> List<Input>

Filters inputs by Address.

let filtered_inputs = inputs_at(inputs, address)


i_at(address: Address) -> fn(Input) -> Bool

Predicate to filter inputs by Address, can be used as grouping inputs for example.

let predicate = i_at(address)
let (grouped_inputs, other_inputs) = group_inputs(inputs, predicate)


inputs_with(
  inputs: List<Input>,
  policy: PolicyId,
  name: AssetName,
) -> List<Input>

Filters inputs by PolicyId and AssetName.

let filtered_inputs = inputs_with(inputs, policy, name)


i_with(policy: PolicyId, name: AssetName) -> fn(Input) -> Bool

Predicate to filter inputs by PolicyId and AssetName, can be used as grouping inputs for example.

let predicate = i_with(policy, name)
let (grouped_inputs, other_inputs) = group_inputs(inputs, predicate)


inputs_with_policy(inputs: List<Input>, policy: PolicyId) -> List<Input>

Filters inputs by token policy.

let filtered_inputs = inputs_with_policy(inputs, policy)


i_with_policy(policy: PolicyId) -> fn(Input) -> Bool

Predicate to filter inputs by token policy, can be used as grouping inputs for example.

let predicate = i_with_policy(policy)
let (grouped_inputs, other_inputs) = group_inputs(inputs, predicate)


inputs_at_with(
  inputs: List<Input>,
  address: Address,
  policy: PolicyId,
  name: AssetName,
) -> List<Input>

Filters inputs by Address, PolicyId, and AssetName.

let filtered_inputs = inputs_at_with(inputs, address, policy, name)


i_at_with(
  address: Address,
  policy: PolicyId,
  name: AssetName,
) -> fn(Input) -> Bool

Predicate to filter inputs by Address, PolicyId, and AssetName, can be used as grouping inputs for example.

let predicate = i_at_with(address, policy, name)
let (grouped_inputs, other_inputs) = group_inputs(inputs, predicate)


inputs_at_with_policy(
  inputs: List<Input>,
  address: Address,
  policy: PolicyId,
) -> List<Input>

Filters inputs by Address and PolicyId.

let filtered_inputs = inputs_at_with_policy(inputs, address, policy)


i_at_with_policy(address: Address, policy: PolicyId) -> fn(Input) -> Bool

inputs_token_quantity(inputs: List<Input>, token: (PolicyId, AssetName)) -> Int

Calculate the total quantity of a token in a list of inputs.

let total_quantity = inputs_token_quantity(inputs, token)


group_inputs(
  inputs: List<Input>,
  group: fn(Input) -> Bool,
) -> (List<Input>, List<Input>)

Group inputs into two lists based on a predicate. First list contains inputs that satisfy the predicate, second list contains the rest.

let (grouped_inputs, other_inputs) = group_inputs(inputs, predicate)


group_inputs_2(
  inputs: List<Input>,
  group1: fn(Input) -> Bool,
  group2: fn(Input) -> Bool,
) -> (List<Input>, List<Input>, List<Input>)

Group inputs into three lists based on two predicates. First list contains inputs that satisfy the first predicate, second list contains inputs that satisfy the second predicate, third list contains the rest.

let (group1_inputs, group2_inputs, other_inputs) = group_inputs_2
Search Document