# Transactions

Balzac provides a simple syntax to express Bitcoin transactions, which is summarized as follows:

```
transaction txName {
input = ...
output = ...
absLock = ... // optional
relLock = ... // optional
}
```

## Inputs

The `input`

field of a transactions specifies

the

**transaction output**, that is a transaction and an output index;the

**witnesses**, that are the actual parameters with which the output script is evaluated.

The syntax to express the pair transaction output/witnesses is `T@n : e1 e2 e3`

,
where `T`

is an expression of type `transaction`

,
`n`

is an integer (not an expression),
and `e1 e2 e3`

are the witnesses expressions whose type must match the type
of the parameters of the transaction output script.

```
transaction A {
...
output = 1 BTC : fun(n:int) . n == 42
}
transaction B {
input = A@0 : 42
...
}
```

Generally, the `input`

field can contains a list of `T@n : wit`

, denoted by the list delimiters `[...]`

and separated by `;`

. Moreover, `@n`

can be omitted and the output index is assumed to be 0.
For example:

```
transaction B {
input = [
A : 42; // same of A@0 : 42
A1@3 : sig(k)
]
...
}
```

See Expressions for details.

## Outputs

The `output`

field of a transactions specifies

the

**bitcoin amount**, that is the value of the output;the

**script**, that is the condition that the redeeming transaction must satisfy.

The syntax to express the pair bitcoin amount/script is `B : fun(x:TypeX,...,y:TypeY) . E`

,
where `B`

is an expression of type `int`

,
`x`

and `y`

are script parameters,
`TypeX`

and `TypeY`

are types (e.g. `int`

, `string`

, …)
and `E`

is an expression of type `boolean`

.

```
transaction A {
...
output = 1 BTC : fun(n:int) . n == 42
}
```

Generally, the `output`

field can contains a list of `B : fun(x:TypeX,...,y:TypeY) . E`

,
denoted by the list delimiters `[...]`

and separated by `;`

.
For example:

```
transaction A {
...
output = [
1 BTC : fun(x:int) . x == 42;
0.5 BTC : fun(y:signature) . versig(k; y)
]
...
}
```

See Expressions for details.

## AbsLock

The field `absLock`

allow to specify when a transaction will be valid.

The time can be expressed in two ways:

`absLock = block N`

where`N`

is an expression of type`int`

representing the**block number**at which the transaction will be valid`absLock = date D`

where`D`

is an expression of type`int`

representing the**date**(in seconds from`1970-01-01`

) at which the transaction will be valid.

The expressions `N`

and `D`

are subject to the same constraints of Absolute timelocks.

Refer to Dates and Delays for convenient ways for expressing dates.

## RelLock

The field `relLock`

allow to specify when a transaction will be valid.

The time can be expressed in two ways:

`relLock = N block from T`

where`N`

and`T`

are expressions of type`int`

and`transaction`

respectively, representing the**number of blocks from T**at which the transaction will be valid`relLock = D from T`

where`D`

and`T`

are expressions of type`int`

and`transaction`

respectively, representing the**seconds from T**at which the transaction will be valid

The expressions `N`

and `D`

are subject to the same constraints of Relative timelocks,
while the expression `T`

must evaluate to one of the input transaction.

Refer to Dates and Delays for convenient ways for expressing delays.