Preparing search index...
The search index is not available
@bitauth/libauth
@bitauth/libauth
ImmutableSet
Type alias ImmutableSet<T>
Immutable
Set
<
T
>
:
ReadonlySet
<
Immutable
<
T
>
>
Type Parameters
T
Settings
Member Visibility
Protected
Private
Inherited
External
Theme
OS
Light
Dark
Modules
@bitauth/libauth
Authentication
ErrorBCH2022
Authentication
ErrorBCH2023
Authentication
ErrorBCHCHIPs
Authentication
Error
Common
Base58
Address
Error
Base58
Address
Format
Version
Base
Conversion
Error
Bech32
Decoding
Error
Bit
Regrouping
Error
Built
In
Variables
Cash
Address
Correction
Error
Cash
Address
Decoding
Error
Cash
Address
Encoding
Error
Cash
Address
Network
Prefix
Cash
Address
Type
Cash
Address
Type
Bits
Cash
Address
Version
Byte
Cash
Address
Version
Byte
Decoding
Error
Cash
Token
Decoding
Error
Compact
Uint
Error
Compact
Uint
Prefixed
Bin
Error
Compiler
Defaults
Compression
Flag
ConsensusBCH2023
ConsensusBCHCHIPs
Consensus
Common
ConsensusXEC
Context
Flag
Hd
Key
Decoding
Error
Hd
Key
Version
Hd
Node
Cracking
Error
Hd
Node
Derivation
Error
Identifier
Resolution
Error
Type
Identifier
Resolution
Type
Locking
Bytecode
Generation
Error
Locking
Bytecode
Type
Locktime
Error
Non
Fungible
Token
Capability
Opcode
DescriptionsBCH2022
Opcode
DescriptionsBCH2023
Opcode
DescriptionsBCHCHIPs
Opcode
DescriptionsBTC
Opcode
DescriptionsXEC
OpcodesBCH2022
OpcodesBCH2023
OpcodesBCHCHIPs
OpcodesBTC
OpcodesXEC
Read
Bytes
Error
Read
Item
Count
Error
Read
Uint32LEError
Read
Uint64LEError
Secp256k1
Error
Signing
Serialization
Algorithm
Identifier
Signing
Serialization
Flag
Signing
Serialization
Type
Transaction
Decoding
Error
Vm
Number
Error
Wallet
Import
Format
Error
Authentication
Instruction
Operation
Authentication
Instruction
Push
Authentication
Instruction
Push
Malformed
Data
Authentication
Instruction
Push
Malformed
Length
Authentication
Program
Common
Authentication
Program
State
Alternate
Stack
Authentication
Program
StateBCHCHIPs
Authentication
Program
StateBTC
Authentication
Program
State
Code
Separator
Authentication
Program
State
Common
Authentication
Program
State
Control
Stack
Authentication
Program
State
Error
Authentication
Program
State
Minimum
Authentication
Program
State
Resource
Limits
Authentication
Program
State
Resource
LimitsBCHCHIPs
Authentication
Program
State
Signature
Analysis
Authentication
Program
State
Stack
Authentication
Program
State
Transaction
Context
Authentication
Template
Authentication
Template
Address
Data
Authentication
Template
Entity
Authentication
Template
Hd
Key
Authentication
Template
Key
Authentication
Template
Scenario
Authentication
Template
Scenario
Data
Authentication
Template
Scenario
Input
Authentication
Template
Scenario
Output
Authentication
Template
Script
Authentication
Template
Script
Locking
Authentication
Template
Script
Test
Authentication
Template
Script
Tested
Authentication
Template
Script
Unlocking
Authentication
Template
Variable
Base
Authentication
Template
Wallet
Data
Authentication
Virtual
Machine
Base
Converter
Bytecode
Generation
Completion
Base
Bytecode
Generation
Completion
Input
Bytecode
Generation
Completion
Output
Bytecode
Generation
Error
Base
Bytecode
Generation
Error
Locking
Bytecode
Generation
Error
Unlocking
Cash
Assembly
Resolution
Cash
Assembly
Script
Segment
Compilation
Context
Compilation
Data
Compilation
Directive
Locking
Compilation
Directive
Unlocking
Compilation
Directive
Unlocking
Estimate
Compilation
Error
Fatal
Compilation
Error
Recoverable
Compilation
Result
Error
Base
Compilation
Result
Parse
Error
Compilation
Result
Reduce
Compilation
Result
Reduce
Error
Compilation
Result
Resolve
Compilation
Result
Resolve
Error
Compilation
Result
Success
Compiler
Compiler
Configuration
Compiler
Operation
Debug
Compiler
Operation
Error
Fatal
Compiler
Operation
Error
Recoverable
Compiler
Operation
Skip
Compiler
Operation
Success
Data
Signature
Compiler
Operation
Success
Generic
Compiler
Operation
Success
Signature
Evaluation
Sample
Hash
Function
Hd
Key
Parameters
Hd
Private
Node
Invalid
Hd
Private
Node
Known
Parent
Hd
Private
Node
Valid
Hd
Public
Node
Hd
Public
Node
Known
Parent
Immutable
Uint8
Array
Input
Instruction
Aggregation
Instruction
Aggregation
Error
Instruction
Aggregation
Success
Instruction
Set
Instruction
Set
Operation
Mapping
Known
Address
Type
Contents
Marked
Node
Output
Range
Read
Position
Read
Result
Recoverable
Signature
Resolution
Debug
Resolution
Signature
Resolved
Script
Resolved
Segment
Comment
Resolved
Segment
Error
Resolved
Segment
Evaluation
Resolved
Segment
Literal
Bytecode
Resolved
Segment
Opcode
Bytecode
Resolved
Segment
Push
Resolved
Segment
Script
Bytecode
Resolved
Segment
Variable
Bytecode
Resolved
Transaction
Common
Ripemd160
Sample
Extraction
Result
Scenario
Scenario
Generation
Debugging
Result
Script
Reduction
Trace
Evaluation
Node
Script
Reduction
Trace
Node
Script
Reduction
Trace
Push
Node
Script
Reduction
Trace
Script
Node
Secp256k1
Secp256k1
Wasm
Seg
Wit
State
Sha1
Sha256
Sha512
Signing
Serialization
ComponentsBCH
Signing
Serialization
Transaction
ComponentsBCH
Source
Position
Trace
Sample
Transaction
Common
Transaction
Generation
Success
Unknown
Address
Type
Contents
Address
Contents
Any
Compiler
Configuration
Any
Compiler
Configuration
Ignore
Operations
Assert
Types
Equal
Authentication
Instruction
Authentication
Instruction
Malformed
Authentication
Instruction
Maybe
Malformed
Authentication
Instructions
Authentication
Instructions
Malformed
Authentication
Instructions
Maybe
Malformed
Authentication
Program
Authentication
ProgramBCH
Authentication
Program
State
Authentication
Program
StateBCH
Authentication
Program
State
Control
StackCHIPs
Authentication
Template
Scenario
Bytecode
Authentication
Template
Scenario
Source
Output
Authentication
Template
Scenario
Transaction
Output
Authentication
Template
Variable
Authentication
Virtual
MachineBCH
Authentication
Virtual
MachineBCHCHIPs
Authentication
Virtual
Machine
Identifier
Base58
Address
Network
Bytecode
Generation
Completion
Bytecode
Generation
Result
Cash
Address
Available
Type
Bits
Cash
Address
Size
Bits
Cash
Address
Supported
Length
Compilation
ContextBCH
Compilation
Context
Common
Compilation
Error
Compilation
Result
Compilation
Result
Error
CompilerBCH
Compiler
ConfigurationBCH
Compiler
Operation
Compiler
Operation
Error
Compiler
Operation
Result
Compiler
Operation
Success
Compiler
Operation
Success
Signature
Type
Compiler
Operations
KeyBCH
Compiler
Operations
Keys
Common
Compiler
Operations
Signing
Serialization
Common
Compiler
Operations
Signing
Serialization
Component
Compiler
Operations
Signing
Serialization
Full
Extended
Scenario
Definition
Hd
Key
Network
Hd
Private
Node
Identifier
Resolution
Function
Immutable
Immutable
Array
Immutable
Map
Immutable
Object
Immutable
Primitive
Immutable
Set
Input
Template
Maybe
Read
Result
Operation
Output
Template
Parse
Result
Partial
Exact
Optional
Read
Function
Recovery
Id
Resolved
Segment
Resolved
Segment
Bytecode
Resolved
Segment
Literal
Type
Resolved
Transaction
Resolved
TransactionBCH
Scenario
Definition
Script
Reduction
Trace
Child
Node
Test
Set
IdBCH
Test
State
Transaction
TransactionBCH
Transaction
Generation
Attempt
Transaction
Generation
Error
Transaction
Template
Transaction
Template
Estimated
Transaction
Template
Fixed
Vmb
Test
Vmb
Test
Definition
Vmb
Test
Definition
Group
Vmb
Test
MasterBCH
Wallet
Import
Format
Type
Authentication
ErrorBCH
ConsensusBCH
Opcode
Descriptions
Opcode
DescriptionsBCH
Opcodes
OpcodesBCH
Signing
Serialization
TypeBCH
Signing
Serialization
TypesBCH
Signing
Serialization
TypesBCH2023
Signing
Serialization
Types
Common
authentication
Template
P2pkh
authentication
Template
P2pkh
Non
Hd
bech32
Character
Set
bech32
Character
Set
Index
bitcoin
Base58
Alphabet
bitcoin
Satoshi
Opcodes
cash
Address
Length
To
Size
Bits
cash
Address
Size
Bits
To
Length
cash
Address
Type
Bits
To
Type
cash
Address
Type
To
Type
Bits
compiler
OperationsBCH
compiler
Operations
Common
excessive
Satoshis
maximum
Locktime
Date
maximum
Locktime
Timestamp
minimum
Locktime
Date
minimum
Locktime
Timestamp
nft
Capability
Label
To
Number
nft
Capability
Number
To
Label
ripemd160
secp256k1
sha1
sha256
sha512
supported
Test
Set
OverridesBCH
vmb
Test
Definition
Default
BehaviorBCH
address
Contents
To
Locking
Bytecode
all
Errors
Are
Recoverable
apply
Error
assemble
Bitcoin
Satoshi
Script
assemble
Bytecode
assemble
BytecodeBCH
assemble
BytecodeBTC
attempt
Cash
Address
Format
Error
Correction
attempt
Compiler
Operations
authentication
Instruction
Is
Malformed
authentication
Instructions
Are
Malformed
authentication
Instructions
Are
Push
Instructions
authentication
Template
To
CompilerBCH
authentication
Template
To
Compiler
Configuration
base58
Address
To
Locking
Bytecode
base58
To
Bin
base64
To
Bin
bech32
Padded
To
Bin
big
Int
To
Bin
Uint256BEClamped
big
Int
To
Bin
Uint64LE
big
Int
To
Bin
Uint64LEClamped
big
Int
To
Bin
UintLE
big
Int
To
Compact
Uint
big
Int
To
Vm
Number
bin
String
To
Bin
bin
To
Base58
bin
To
Base64
bin
To
Bech32
Padded
bin
To
Big
Int
Uint256BE
bin
To
Big
Int
Uint64LE
bin
To
Big
Int
UintBE
bin
To
Big
Int
UintLE
bin
To
Bin
String
bin
To
Fixed
Length
bin
To
Hex
bin
To
Number
Int16LE
bin
To
Number
Int32LE
bin
To
Number
Uint16LE
bin
To
Number
Uint32LE
bin
To
Number
UintLE
bin
To
Utf8
bin
To
Value
Satoshis
bins
Are
Equal
bitwise
Operation
boolean
To
Vm
Number
cash
Address
Checksum
To
Uint5
Array
cash
Address
Polynomial
Modulo
cash
Address
Polynomial
To
Cash
Address
cash
Address
To
Locking
Bytecode
cash
Assembly
To
Bin
check
Limits
Common
clone
Authentication
Instruction
clone
Authentication
Program
Common
clone
Authentication
Program
State
clone
Authentication
Program
StateBCH
clone
Authentication
Program
StateBCHCHIPs
clone
Authentication
Program
State
Common
clone
Stack
clone
Transaction
Common
clone
Transaction
Inputs
Common
clone
Transaction
Outputs
Common
combine
Operations
compact
Uint
Prefix
To
Size
compact
Uint
To
Big
Int
compile
Authentication
Template
Scenario
Bytecode
compile
Authentication
Template
Scenario
Value
Satoshis
compile
Cash
Assembly
compile
Input
Template
compile
Output
Template
compile
Scenario
Output
Token
Data
compile
Script
compile
Script
Contents
compile
Script
Raw
compiler
Configuration
To
Compiler
compiler
Configuration
To
CompilerBCH
compiler
Operation
Address
Data
compiler
Operation
Attempt
Bytecode
Resolution
compiler
Operation
Current
Block
Height
compiler
Operation
Current
Block
Time
compiler
Operation
Hd
Key
Ecdsa
Data
SignatureBCH
compiler
Operation
Hd
Key
Ecdsa
SignatureBCH
compiler
Operation
Hd
Key
Public
Key
Common
compiler
Operation
Hd
Key
Schnorr
Data
SignatureBCH
compiler
Operation
Hd
Key
Schnorr
SignatureBCH
compiler
Operation
Helper
Address
Index
compiler
Operation
Helper
Compile
Script
compiler
Operation
Helper
Compute
Data
SignatureBCH
compiler
Operation
Helper
Compute
SignatureBCH
compiler
Operation
Helper
Derive
Hd
Key
Private
compiler
Operation
Helper
Derive
Hd
Private
Node
compiler
Operation
Helper
Generate
Covered
Bytecode
compiler
Operation
Helper
Hd
Key
Data
SignatureBCH
compiler
Operation
Helper
Hd
Key
SignatureBCH
compiler
Operation
Helper
Key
Data
SignatureBCH
compiler
Operation
Helper
Key
SignatureBCH
compiler
Operation
Helper
Unknown
Entity
compiler
Operation
Key
Ecdsa
Data
SignatureBCH
compiler
Operation
Key
Ecdsa
SignatureBCH
compiler
Operation
Key
Public
Key
Common
compiler
Operation
Key
Schnorr
Data
SignatureBCH
compiler
Operation
Key
Schnorr
SignatureBCH
compiler
Operation
Requires
compiler
Operation
Signing
Serialization
Corresponding
Output
compiler
Operation
Signing
Serialization
Corresponding
Output
Hash
compiler
Operation
Signing
Serialization
Covered
Bytecode
compiler
Operation
Signing
Serialization
Covered
Bytecode
Length
compiler
Operation
Signing
Serialization
FullBCH
compiler
Operation
Signing
Serialization
Locktime
compiler
Operation
Signing
Serialization
Outpoint
Index
compiler
Operation
Signing
Serialization
Outpoint
Transaction
Hash
compiler
Operation
Signing
Serialization
Output
Value
compiler
Operation
Signing
Serialization
Sequence
Number
compiler
Operation
Signing
Serialization
Transaction
Outpoints
compiler
Operation
Signing
Serialization
Transaction
Outpoints
Hash
compiler
Operation
Signing
Serialization
Transaction
Outputs
compiler
Operation
Signing
Serialization
Transaction
Outputs
Hash
compiler
Operation
Signing
Serialization
Transaction
Sequence
Numbers
compiler
Operation
Signing
Serialization
Transaction
Sequence
Numbers
Hash
compiler
Operation
Signing
Serialization
Version
compiler
Operation
Wallet
Data
conditionally
Evaluate
conditionally
Evaluate
Chip
Loops
contains
Range
crack
Hd
Private
Node
From
Hd
Public
Node
And
Child
Private
Node
create
Authentication
Program
Evaluation
Common
create
Authentication
Program
StateBCHCHIPs
create
Authentication
Program
State
Common
create
Authentication
Virtual
Machine
create
Base
Converter
create
Compilation
Context
Common
Testing
create
Compiler
create
CompilerBCH
create
Compiler
Common
create
Compiler
Generate
Bytecode
Function
create
Empty
Range
create
Identifier
Resolver
create
Instruction
SetBCH
create
Instruction
SetBCH2022
create
Instruction
SetBCH2023
create
Instruction
SetBCHCHIPs
create
Instruction
SetXEC
create
Test
Authentication
ProgramBCH
create
Virtual
MachineBCH
create
Virtual
MachineBCH2022
create
Virtual
MachineBCH2023
create
Virtual
MachineBCHCHIPs
create
Virtual
MachineXEC
date
To
Locktime
date
To
Locktime
Bin
decode
Authentication
Instruction
decode
Authentication
Instructions
decode
Base58
Address
decode
Base58
Address
Format
decode
Bech32
decode
Bitcoin
Signature
decode
Cash
Address
decode
Cash
Address
Format
decode
Cash
Address
Format
Without
Prefix
decode
Cash
Address
Non
Standard
decode
Cash
Address
Version
Byte
decode
Hd
Key
decode
Hd
Private
Key
decode
Hd
Public
Key
decode
Little
Endian
Number
decode
Locktime
decode
Private
Key
Wif
decode
Transaction
decode
TransactionBCH
decode
Transaction
Common
decode
Transaction
Unsafe
decode
Transaction
UnsafeBCH
decode
Transaction
Unsafe
Common
derive
Hd
Path
derive
Hd
Private
Node
Child
derive
Hd
Private
Node
From
Seed
derive
Hd
Private
Node
Identifier
derive
Hd
Public
Node
derive
Hd
Public
Node
Child
derive
Hd
Public
Node
Identifier
describe
Expected
Input
disabled
Operation
disassemble
Authentication
Instruction
disassemble
Authentication
Instruction
Malformed
disassemble
Authentication
Instruction
Maybe
Malformed
disassemble
Authentication
Instructions
Maybe
Malformed
disassemble
Bytecode
disassemble
BytecodeBCH
disassemble
BytecodeBTC
encode
Authentication
Instruction
encode
Authentication
Instruction
Malformed
encode
Authentication
Instruction
Maybe
Malformed
encode
Authentication
Instructions
encode
Authentication
Instructions
Maybe
Malformed
encode
Base58
Address
encode
Base58
Address
Format
encode
Bech32
encode
Cash
Address
encode
Cash
Address
Format
encode
Cash
Address
Non
Standard
encode
Cash
Address
Version
Byte
encode
Data
Push
encode
Hd
Private
Key
encode
Hd
Public
Key
encode
Locking
Bytecode
P2pk
encode
Locking
Bytecode
P2pkh
encode
Locking
Bytecode
P2sh20
encode
Locking
Bytecode
P2sh32
encode
Private
Key
Wif
encode
Signing
SerializationBCH
encode
Token
Prefix
encode
Transaction
encode
TransactionBCH
encode
Transaction
Common
encode
Transaction
Input
encode
Transaction
Input
Sequence
Numbers
For
Signing
encode
Transaction
Inputs
encode
Transaction
Outpoints
encode
Transaction
Output
encode
Transaction
Outputs
encode
Transaction
Outputs
For
Signing
extend
Compilation
Data
With
Scenario
Bytecode
extend
Scenario
Definition
extend
Scenario
Definition
Data
extended
Scenario
Definition
To
Compilation
Data
extract
Bytecode
Resolutions
extract
Evaluation
Samples
extract
Evaluation
Samples
Recursive
extract
Genesis
Categories
extract
Missing
Variables
extract
Resolved
Variable
Bytecode
Map
extract
Resolved
Variables
extract
Source
Output
Token
Data
extract
Transaction
Output
Token
Data
extract
Unexecuted
Ranges
flatten
Bin
Array
format
Error
generate
Bytecode
Map
generate
Default
Scenario
Definition
generate
Extended
Scenario
generate
Private
Key
generate
ScenarioBCH
generate
Signing
SerializationBCH
generate
Signing
Serialization
ComponentsBCH
generate
Transaction
get
Dust
Threshold
get
Embedded
Ripemd160
Binary
get
Embedded
Secp256k1
Binary
get
Embedded
Sha1
Binary
get
Embedded
Sha256
Binary
get
Embedded
Sha512
Binary
get
Minimum
Fee
get
Resolution
Errors
hash160
hash256
hash
Digest
Iterations
hash
Outputs
hash
Prevouts
hash
Sequence
hash
Transaction
hash
Transaction
P2p
Order
hash
Transaction
Ui
Order
hash
Utxos
hd
Private
Key
To
Identifier
hd
Private
Key
To
P2pkh
Address
hd
Private
Key
To
P2pkh
Locking
Bytecode
hd
Public
Key
To
Identifier
hex
To
Bin
hmac
Sha256
hmac
Sha512
import
Authentication
Template
increment
Hash
Digest
Iterations
increment
Operation
Count
instantiate
Hmac
Function
instantiate
Ripemd160
instantiate
Ripemd160
Bytes
instantiate
Rust
Wasm
instantiate
Secp256k1
instantiate
Secp256k1
Bytes
instantiate
Secp256k1
Wasm
instantiate
Secp256k1
Wasm
Bytes
instantiate
Sha1
instantiate
Sha1
Bytes
instantiate
Sha256
instantiate
Sha256
Bytes
instantiate
Sha512
instantiate
Sha512
Bytes
int32
Signed
To
Unsigned
int32
Unsigned
To
Signed
is
Arbitrary
Data
Output
is
Base64
is
Bech32
Character
Set
is
Bin
String
is
Dust
Output
is
Hex
is
Legacy
Signing
Serialization
is
Minimal
Data
Push
is
Pay
To
Public
Key
is
Pay
To
Public
Key
Compressed
is
Pay
To
Public
Key
Hash
is
Pay
To
Public
Key
Uncompressed
is
Pay
To
Script
Hash20
is
Pay
To
Script
Hash32
is
Push
Only
is
Push
Only
Accurate
is
Push
Operation
is
Simple
Multisig
is
Standard
Multisig
is
Standard
Output
Bytecode
is
Standard
Output
Bytecode2023
is
Valid
Cash
Address
Payload
Length
is
Valid
Compressed
Public
Key
Encoding
is
Valid
Public
Key
Encoding
is
Valid
Signature
EncodingBCHRaw
is
Valid
Signature
EncodingBCHTransaction
is
Valid
Signature
EncodingDER
is
Valid
Uncompressed
Public
Key
Encoding
is
Vm
Number
Error
is
Witness
Program
locking
Bytecode
To
Address
Contents
locking
Bytecode
To
Base58
Address
locking
Bytecode
To
Cash
Address
locktime
To
Date
map
Over
Operations
mask
Cash
Address
Prefix
merge
Ranges
number
To
Bin
Int16LE
number
To
Bin
Int32LE
number
To
Bin
Int32
Twos
Compliment
number
To
Bin
Uint16BE
number
To
Bin
Uint16LE
number
To
Bin
Uint16LEClamped
number
To
Bin
Uint32BE
number
To
Bin
Uint32LE
number
To
Bin
Uint32LEClamped
number
To
Bin
UintLE
op0
Not
Equal
op1
Add
op1
Sub
op2
Drop
op2
Dup
op2
Over
op2
Rot
op2
Swap
op3
Dup
op
Abs
op
Active
Bytecode
op
Add
op
And
op
Begin
op
Bin2
Num
op
Bool
And
op
Bool
Or
op
Cat
op
Check
Data
Sig
op
Check
Data
Sig
Chip
Limits
op
Check
Data
Sig
Verify
op
Check
Data
Sig
Verify
Chip
Limits
op
Check
Lock
Time
Verify
op
Check
Multi
Sig
op
Check
Multi
SigBCH2023
op
Check
Multi
Sig
Chip
Limits
op
Check
Multi
Sig
Verify
op
Check
Multi
Sig
VerifyBCH2023
op
Check
Multi
Sig
Verify
Chip
Limits
op
Check
Sequence
Verify
op
Check
Sig
op
Check
SigBCH2023
op
Check
Sig
Chip
Limits
op
Check
Sig
Verify
op
Check
Sig
VerifyBCH2023
op
Check
Sig
Verify
Chip
Limits
op
Code
Separator
op
Depth
op
Div
op
Drop
op
Dup
op
Else
op
Else
Chip
Loops
op
End
If
op
End
If
Chip
Loops
op
Equal
op
Equal
Verify
op
From
Alt
Stack
op
Greater
Than
op
Greater
Than
Or
Equal
op
Hash160
op
Hash160
Chip
Limits
op
Hash256
op
Hash256
Chip
Limits
op
If
op
If
Chip
Loops
op
If
Dup
op
Input
Bytecode
op
Input
Index
op
Input
Sequence
Number
op
Less
Than
op
Less
Than
Or
Equal
op
Max
op
Min
op
Mod
op
Mul
op
Negate
op
Nip
op
Nop
op
Nop
Disallowed
op
Not
op
Not
If
op
Not
If
Chip
Loops
op
Num2
Bin
op
Num
Equal
op
Num
Equal
Verify
op
Num
Not
Equal
op
Or
op
Outpoint
Index
op
Outpoint
Tx
Hash
op
Output
Bytecode
op
Output
Token
Amount
op
Output
Token
Category
op
Output
Token
Commitment
op
Output
Value
op
Over
op
Pick
op
Return
op
Reverse
Bytes
op
Ripemd160
op
Ripemd160
Chip
Limits
op
Roll
op
Rot
op
Sha1
op
Sha1
Chip
Limits
op
Sha256
op
Sha256
Chip
Limits
op
Size
op
Split
op
Sub
op
Swap
op
To
Alt
Stack
op
Tuck
op
Tx
Input
Count
op
Tx
Locktime
op
Tx
Output
Count
op
Tx
Version
op
Until
op
Utxo
Bytecode
op
Utxo
Token
Amount
op
Utxo
Token
Category
op
Utxo
Token
Commitment
op
Utxo
Value
op
Verify
op
Within
op
Xor
opcode
To
Push
Length
pad
Minimally
Encoded
Vm
Number
parse
Script
push
Number
Opcode
To
Number
push
Number
Operation
push
Operation
push
Operation
Chip
Loops
push
To
Control
Stack
Chip
Loops
push
To
Stack
push
To
Stack
Checked
push
To
Stack
Vm
Number
push
To
Stack
Vm
Number
Checked
push
Token
Amount
push
Token
Commitment
push
Token
Extended
Category
range
read
Bytes
read
Compact
Uint
read
Compact
Uint
Minimal
read
Compact
Uint
Prefixed
Bin
read
Item
Count
read
Locking
Bytecode
With
Prefix
read
Multiple
read
Remaining
Bytes
read
Token
Amount
read
Token
Prefix
read
Transaction
read
Transaction
Common
read
Transaction
Input
read
Transaction
Inputs
read
Transaction
Non
Token
Aware
read
Transaction
Output
read
Transaction
Output
Non
Token
Aware
read
Transaction
Outputs
read
Transaction
Outputs
Non
Token
Aware
read
Uint32LE
read
Uint64LE
reduce
Script
regroup
Bits
reserved
Operation
resolve
Script
Identifier
resolve
Script
Segment
resolve
Variable
Identifier
safely
Extend
Compilation
Data
sort
Object
Keys
split
Every
stack
Item
Is
Truthy
stringify
stringify
Debug
Trace
Summary
stringify
Errors
stringify
Test
Vector
summarize
Debug
Trace
summarize
Stack
swap
Endianness
undefined
Operation
undefined
Operation
Chip
Loops
unknown
Value
use
Four
Stack
Items
use
Locktime
use
One
Stack
Item
use
One
Vm
Number
use
Six
Stack
Items
use
Three
Stack
Items
use
Three
Vm
Numbers
use
Transaction
Input
use
Transaction
Output
use
Transaction
Utxo
use
Two
Stack
Items
use
Two
Vm
Numbers
utf8
To
Bin
validate
Secp256k1
Private
Key
value
Satoshis
To
Bin
verify
Cash
Assembly
Evaluation
State
verify
Transaction
Tokens
vm
Number
To
Big
Int
vmb
Test
Definition
To
Vmb
Tests
vmb
Test
Group
To
Vmb
Tests
vmb
Test
Partition
Master
Test
List
Generated using
TypeDoc