libauth.org Open in urlscan Pro
2606:4700:3030::ac43:ae5a  Public Scan

Form analysis
0 forms found in the DOM

Text Content

Search
 * Preparing search index...
 * The search index is not available

@bitauth/libauth
Options
All
 * Public
 * Public/Protected
 * All

Inherited Externals
Menu
 * Globals


@BITAUTH/LIBAUTH

An ultra-lightweight JavaScript library for Bitcoin, Bitcoin Cash, and Bitauth
applications.

Explore API Reference »




LIBAUTH

An ultra-lightweight JavaScript library for Bitcoin, Bitcoin Cash, and Bitauth
applications.

Libauth has no dependencies and works in all JavaScript environments, including
Node.js, Deno, and browsers.


PURPOSE

Libauth is designed to be flexible, lightweight, and easily auditable. Rather
than providing a single, overarching, object-oriented API, all functionality is
composed from simple functions. This has several benefits:

 * Flexibility – Even highly-complex functionality is built-up from simpler
   functions. These lower-level functions can be used to experiment, tweak, and
   remix your own higher-level methods without maintaining a fork of the
   library.
 * Smaller application bundles – Applications can import only the methods they
   need, eliminating the unused code (via dead-code elimination).
 * Better auditability – Beyond having no dependencies of its own, Libauth's
   functional programming approach makes auditing critical code easier: smaller
   bundles, smaller functions, and less churn between versions (fewer cascading
   changes to object-oriented interfaces).
 * Fully-portable – No platform-specific APIs are ever used, so the same code
   paths are used across all JavaScript environments (reducing the auditable
   "surface area" and simplifying library development).


GETTING STARTED

To get started, install @bitauth/libauth:

npm install @bitauth/libauth
# OR
yarn add @bitauth/libauth

And import the functionality you need:

import { instantiateSecp256k1 } from '@bitauth/libauth';
import { msgHash, pubkey, sig } from './somewhere';

(async () => {
  const secp256k1 = await instantiateSecp256k1();
  secp256k1.verifySignatureDERLowS(sig, pubkey, msgHash)
    ? console.log('🚀 Signature valid')
    : console.log('❌ Signature invalid');
})();


TYPESCRIPT TYPES

Note: @bitauth/libauth uses BigInt, WebAssembly, and es2017 features for some
functionality. While support is required to use this functionality (Node.js v10
LTS or later), other parts of the library will continue to work in older
environments. To include the necessary TypeScript library files in you
application, add "lib": ["es2017", "esnext.bigint", "dom"] to your
tsconfig.json.


USING WITH DENO

Deno is a great runtime for quickly working with Libauth. You can import from
the latest module build:

import { hexToBin } from 'https://unpkg.com/@bitauth/libauth/build/module/index.js';

console.log(hexToBin('beef'));


STABLE API

The following APIs are considered stable, and will only include breaking changes
in major version upgrades.


WEBASSEMBLY ECDSA & SCHNORR

 * instantiateSecp256k1
 * Secp256k1 Interface


WEBASSEMBLY HASHING FUNCTIONS

 * instantiateRipemd160
 * Ripemd160 Interface
 * instantiateSha1
 * Sha1 Interface
 * instantiateSha256
 * Sha256 Interface
 * instantiateSha512
 * Sha512 Interface


UNSTABLE APIS

Libauth also exports new, potentially unstable APIs. As these APIs stabilize,
they will be included in the above reference.

Full API Documentation →

--------------------------------------------------------------------------------

Contributing

Pull Requests welcome! Please see CONTRIBUTING.md for details.

This library requires Yarn for development. If you don't have Yarn, make sure
you have Node.js installed (which ships with npm), then run npm install -g yarn.
Once Yarn is installed:

# use --recursive to clone the secp256k1 submodule
git clone --recursive https://github.com/bitauth/libauth.git && cd libauth

Install the development dependencies:

yarn

Then try running the test suite:

yarn test

You can also run the benchmarks (this will take a while):

yarn bench

During development, you may find it helpful to use the testing watch tasks:

yarn watch # rebuild everything on save
yarn watch:test # run only the fast tests
yarn watch:test-slow # test everything

For more information about the available package scripts, run:

yarn run info

 * Globals

 * ASN1
 * AddressType
 * AuthenticationErrorBCH
 * AuthenticationErrorCommon
 * Base58AddressError
 * Base58AddressFormatVersion
 * BaseConversionError
 * Bech32DecodingError
 * BitRegroupingError
 * Bits
 * BuiltInVariables
 * ByteLength
 * CashAddressCorrectionError
 * CashAddressDecodingError
 * CashAddressEncodingError
 * CashAddressNetworkPrefix
 * CashAddressType
 * CashAddressVersionByte
 * CashAddressVersionByteDecodingError
 * CommonPushOpcodes
 * CompilerDefaults
 * CompressionFlag
 * ConsensusBCH
 * ConsensusCommon
 * Constants
 * ContextFlag
 * DER
 * HdKeyDecodingError
 * HdKeyVersion
 * HdNodeCrackingError
 * HdNodeDerivationError
 * IdentifierResolutionErrorType
 * IdentifierResolutionType
 * InstructionSetBCH
 * Internal
 * LockingBytecodeEncodingError
 * LocktimeError
 * Mask
 * Multisig
 * OpcodeAlternateNamesBCH
 * OpcodeDescriptionsCommon
 * OpcodeDescriptionsUniqueBCH
 * OpcodesBCH
 * OpcodesBTC
 * OpcodesCommon
 * PayToScriptHash
 * PublicKey
 * PushOperationConstants
 * ScriptNumberError
 * SegWit
 * SigningSerializationAlgorithmIdentifier
 * SigningSerializationFlag
 * TransactionDecodingError
 * VarInt
 * WalletImportFormatError
 * AddressContents
 * AuthenticationInstructionOperation
 * AuthenticationInstructionPush
 * AuthenticationProgramBCH
 * AuthenticationProgramCommon
 * AuthenticationProgramStateAlternateStack
 * AuthenticationProgramStateBCH
 * AuthenticationProgramStateBTC
 * AuthenticationProgramStateCommon
 * AuthenticationProgramStateError
 * AuthenticationProgramStateExecutionStack
 * AuthenticationProgramStateInternalCommon
 * AuthenticationProgramStateMinimum
 * AuthenticationProgramStateSignatureAnalysis
 * AuthenticationProgramStateStack
 * AuthenticationProgramTransactionContextCommon
 * AuthenticationTemplate
 * AuthenticationTemplateAddressData
 * AuthenticationTemplateEntity
 * AuthenticationTemplateHdKey
 * AuthenticationTemplateKey
 * AuthenticationTemplateScenario
 * AuthenticationTemplateScenarioData
 * AuthenticationTemplateScenarioInput
 * AuthenticationTemplateScenarioOutput
 * AuthenticationTemplateScript
 * AuthenticationTemplateScriptLocking
 * AuthenticationTemplateScriptTest
 * AuthenticationTemplateScriptTested
 * AuthenticationTemplateScriptUnlocking
 * AuthenticationTemplateVariableBase
 * AuthenticationTemplateWalletData
 * AuthenticationVirtualMachine
 * BaseConverter
 * BitauthTemplatingLanguageSegment
 * BtlRecursiveSegment
 * BtlResolution
 * BtlScriptSegment
 * BtlStringSegment
 * BytecodeGenerationCompletionBase
 * BytecodeGenerationCompletionInput
 * BytecodeGenerationCompletionOutput
 * BytecodeGenerationErrorBase
 * BytecodeGenerationErrorLocking
 * BytecodeGenerationErrorUnlocking
 * CompilationData
 * CompilationDirectiveLocking
 * CompilationDirectiveUnlocking
 * CompilationDirectiveUnlockingEstimate
 * CompilationEnvironment
 * CompilationErrorFatal
 * CompilationErrorRecoverable
 * CompilationResultErrorBase
 * CompilationResultParseError
 * CompilationResultReduce
 * CompilationResultReduceError
 * CompilationResultResolve
 * CompilationResultResolveError
 * CompilationResultSuccess
 * Compiler
 * CompilerOperationDebug
 * CompilerOperationErrorFatal
 * CompilerOperationErrorRecoverable
 * CompilerOperationSkip
 * CompilerOperationSuccessDataSignature
 * CompilerOperationSuccessGeneric
 * CompilerOperationSuccessSignature
 * EvaluationSample
 * Failure
 * HashFunction
 * HdKeyParameters
 * HdNodeBase
 * HdPrivateNodeInvalid
 * HdPrivateNodeKnownParent
 * HdPrivateNodeValid
 * HdPublicNode
 * HdPublicNodeKnownParent
 * Index
 * Input
 * InstructionAggregation
 * InstructionAggregationError
 * InstructionAggregationSuccess
 * InstructionSet
 * InstructionSetOperationMapping
 * Mark
 * MarkedNode
 * Node
 * Output
 * ParsedAuthenticationInstructionPushMalformedData
 * ParsedAuthenticationInstructionPushMalformedLength
 * Parser
 * Range
 * RecoverableSignature
 * ResolutionDebug
 * ResolutionSignature
 * ResolvedScript
 * ResolvedSegmentBase
 * ResolvedSegmentComment
 * ResolvedSegmentError
 * ResolvedSegmentEvaluation
 * ResolvedSegmentLiteralBytecode
 * ResolvedSegmentOpcodeBytecode
 * ResolvedSegmentPush
 * ResolvedSegmentScriptBytecode
 * ResolvedSegmentVariableBytecode
 * Ripemd160
 * SampleExtractionResult
 * Scenario
 * ScriptReductionTraceErrorNode
 * ScriptReductionTraceEvaluationNode
 * ScriptReductionTraceNode
 * ScriptReductionTracePushNode
 * ScriptReductionTraceScriptNode
 * Secp256k1
 * Secp256k1Wasm
 * SegWitState
 * Sha1
 * Sha256
 * Sha512
 * SourcePosition
 * Success
 * TraceSample
 * Transaction
 * TransactionContextCommon
 * TransactionContextSharedCommon
 * TransactionGenerationSuccess
 * AnyCompilationEnvironment
 * AnyCompilationEnvironmentIgnoreOperations
 * AuthenticationInstruction
 * AuthenticationInstructions
 * AuthenticationTemplateVariable
 * AuthenticationVirtualMachineIdentifier
 * Base58AddressNetwork
 * BytecodeGenerationCompletion
 * BytecodeGenerationResult
 * CashAddressAvailableSizes
 * CashAddressAvailableSizesInBits
 * CashAddressAvailableTypes
 * CompilationEnvironmentBCH
 * CompilationError
 * CompilationResult
 * CompilationResultError
 * CompilerOperation
 * CompilerOperationError
 * CompilerOperationResult
 * CompilerOperationSuccess
 * CompilerOperationSuccessSignatureType
 * CompilerOperationsKeyBCH
 * CompilerOperationsKeysCommon
 * CompilerOperationsSigningSerializationCommon
 * CompilerOperationsSigningSerializationComponent
 * CompilerOperationsSigningSerializationFull
 * ExtendedScenarioDefinition
 * HdKeyNetwork
 * HdPrivateNode
 * IdentifierResolutionFunction
 * Immutable
 * ImmutableArray
 * ImmutableMap
 * ImmutableObject
 * ImmutablePrimitive
 * ImmutableSet
 * ImmutableUint8Array
 * InputTemplate
 * MakeOptional
 * Operation
 * OutputTemplate
 * ParseResult
 * ParsedAuthenticationInstruction
 * ParsedAuthenticationInstructionMalformed
 * ParsedAuthenticationInstructions
 * PrivateResults
 * PublicResults
 * RecoveryId
 * RecursiveSegmentType
 * ReductionResults
 * RequiredTwoLevels
 * ResolvedSegment
 * ResolvedSegmentBytecode
 * ResolvedSegmentLiteralType
 * Result
 * ScenarioDefinition
 * ScriptReductionTraceChildNode
 * StringSegmentType
 * TestState
 * TransactionContextBCH
 * TransactionGenerationAttempt
 * TransactionGenerationError
 * TransactionTemplate
 * TransactionTemplateEstimated
 * TransactionTemplateFixed
 * TypedLanguage
 * TypedRule
 * Uint16Bytes
 * Uint32Bytes
 * Uint8Bytes
 * WalletImportFormatType
 * SECP256K1_CONTEXT_NONE
 * SECP256K1_CONTEXT_SIGN
 * SECP256K1_CONTEXT_VERIFY
 * SECP256K1_EC_COMPRESSED
 * SECP256K1_EC_UNCOMPRESSED
 * SECP256K1_FLAGS_BIT_COMPRESSION
 * SECP256K1_FLAGS_BIT_CONTEXT_SIGN
 * SECP256K1_FLAGS_BIT_CONTEXT_VERIFY
 * SECP256K1_FLAGS_TYPE_COMPRESSION
 * SECP256K1_FLAGS_TYPE_CONTEXT
 * _
 * asciiCaseInsensitiveBits
 * asciiLowerCaseStart
 * authenticationScriptParser
 * authenticationTemplateVariableTypes
 * base256WordLength
 * base32WordLength
 * base58
 * base58ToBin
 * base64GroupLength
 * bech32CharacterSet
 * bech32CharacterSetIndex
 * bech32GeneratorMostSignificantByte
 * bech32GeneratorRemainingBytes
 * bigIntRegex
 * binToBase58
 * binary
 * binaryByteWidth
 * bip32HmacSha512Key
 * bitcoinABCOpcodes
 * bitcoinBase58Alphabet
 * cachedRipemd160
 * cachedSecp256k1
 * cachedSha1
 * cachedSha256
 * cachedSha512
 * cashAddressBitToSize
 * cashAddressReservedBitMask
 * cashAddressSizeBits
 * cashAddressSizeToBit
 * cashAddressTypeBitShift
 * cashAddressTypeBits
 * characterLength32BytePrivateKey
 * chars
 * compilerOperationAddressData
 * compilerOperationAttemptBytecodeResolution
 * compilerOperationCurrentBlockHeight
 * compilerOperationCurrentBlockTime
 * compilerOperationHdKeyEcdsaDataSignatureBCH
 * compilerOperationHdKeyEcdsaSignatureBCH
 * compilerOperationHdKeyPublicKeyCommon
 * compilerOperationHdKeySchnorrDataSignatureBCH
 * compilerOperationHdKeySchnorrSignatureBCH
 * compilerOperationKeyEcdsaDataSignatureBCH
 * compilerOperationKeyEcdsaSignatureBCH
 * compilerOperationKeyPublicKeyCommon
 * compilerOperationKeySchnorrDataSignatureBCH
 * compilerOperationKeySchnorrSignatureBCH
 * compilerOperationSigningSerializationCorrespondingOutput
 * compilerOperationSigningSerializationCorrespondingOutputHash
 * compilerOperationSigningSerializationCoveredBytecode
 * compilerOperationSigningSerializationCoveredBytecodeLength
 * compilerOperationSigningSerializationFullBCH
 * compilerOperationSigningSerializationLocktime
 * compilerOperationSigningSerializationOutpointIndex
 * compilerOperationSigningSerializationOutpointTransactionHash
 * compilerOperationSigningSerializationOutputValue
 * compilerOperationSigningSerializationSequenceNumber
 * compilerOperationSigningSerializationTransactionOutpoints
 * compilerOperationSigningSerializationTransactionOutpointsHash
 * compilerOperationSigningSerializationTransactionOutputs
 * compilerOperationSigningSerializationTransactionOutputsHash
 * compilerOperationSigningSerializationTransactionSequenceNumbers
 * compilerOperationSigningSerializationTransactionSequenceNumbersHash
 * compilerOperationSigningSerializationVersion
 * compilerOperationWalletData
 * correspondingOutput
 * defaultStringifySpacing
 * empty
 * eof
 * finiteFieldOrder
 * halfHmacSha512Length
 * hasNonHexCharacter
 * hexByteWidth
 * hexadecimal
 * index
 * instructionSetBCHCurrentStrict
 * invalidSatoshis
 * locktimeByteLength
 * maximumLocktimeDate
 * maximumLocktimeTimestamp
 * minimumLocktimeDate
 * minimumLocktimeTimestamp
 * msPerLocktimeSecond
 * nonBase64Chars
 * nonBech32Characters
 * normalMaximumScriptNumberByteLength
 * nullHashLength
 * op1NegateValue
 * optWhitespace
 * outpointTransactionHashFill
 * outputValueLength
 * payloadSeparator
 * pushByteOpcodes
 * pushNumberOpcodes
 * sha256BlockByteLength
 * sha256HashLength
 * sha512BlockByteLength
 * transactionOutpoints
 * transactionOutputs
 * transactionSequenceNumbers
 * uint16Bytes
 * uint32Bytes
 * uint8ArrayRegex
 * uint8Bytes
 * whitespace
 * Parsimmon
 * addressContentsToLockingBytecode
 * alignMemory
 * allErrorsAreRecoverable
 * alt
 * anchoredRegexp
 * applyError
 * areEqual
 * arithmeticOperations
 * assembleBitcoinABCScript
 * assembleBytecode
 * assembleBytecodeBCH
 * assembleBytecodeBTC
 * attemptCashAddressFormatErrorCorrection
 * attemptCompilerOperation
 * attemptCompilerOperations
 * authenticationInstructionIsMalformed
 * authenticationInstructionsAreMalformed
 * authenticationInstructionsAreNotMalformed
 * authenticationTemplateToCompilationEnvironment
 * authenticationTemplateToCompilationEnvironmentVirtualizedTests
 * authenticationTemplateToCompilerBCH
 * base58AddressToLockingBytecode
 * base64ToBin
 * bech32PaddedToBin
 * bigIntToBinUint256BEClamped
 * bigIntToBinUint64LE
 * bigIntToBinUint64LEClamped
 * bigIntToBinUintLE
 * bigIntToBitcoinVarInt
 * bigIntToScriptNumber
 * binStringToBin
 * binToBase64
 * binToBech32Padded
 * binToBigIntUint256BE
 * binToBigIntUint64LE
 * binToBigIntUintBE
 * binToBigIntUintLE
 * binToBinString
 * binToFixedLength
 * binToHex
 * binToNumberInt16LE
 * binToNumberInt32LE
 * binToNumberUint16LE
 * binToNumberUint32LE
 * binToNumberUintLE
 * binToUtf8
 * bitcoinCashOperations
 * bitwiseOperation
 * bitwiseOperations
 * booleanToScriptNumber
 * cashAddressChecksumToUint5Array
 * cashAddressPolynomialModulo
 * cashAddressPolynomialToCashAddress
 * cashAddressToLockingBytecode
 * checkLimitsCommon
 * cloneAuthenticationProgramStateCommon
 * cloneStack
 * combineOperations
 * commonOperations
 * compileBtl
 * compileInputTemplate
 * compileOutputTemplate
 * compileScript
 * compileScriptContents
 * compileScriptP2shLocking
 * compileScriptP2shUnlocking
 * compileScriptRaw
 * compilerOperationHelperAddressIndex
 * compilerOperationHelperCompileScript
 * compilerOperationHelperComputeDataSignatureBCH
 * compilerOperationHelperComputeSignatureBCH
 * compilerOperationHelperDeriveHdKeyPrivate
 * compilerOperationHelperDeriveHdPrivateNode
 * compilerOperationHelperGenerateCoveredBytecode
 * compilerOperationHelperHdKeyDataSignatureBCH
 * compilerOperationHelperHdKeySignatureBCH
 * compilerOperationHelperKeyDataSignatureBCH
 * compilerOperationHelperKeySignatureBCH
 * compilerOperationHelperSigningSerializationCoveredBytecode
 * compilerOperationHelperUnknownEntity
 * compilerOperationRequires
 * conditionalFlowControlOperations
 * conditionallyEvaluate
 * containsRange
 * crackHdPrivateNodeFromHdPublicNodeAndChildPrivateNode
 * createAuthenticationProgramEvaluationCommon
 * createAuthenticationProgramInternalStateCommon
 * createAuthenticationProgramStateCommon
 * createAuthenticationProgramStateCommonEmpty
 * createAuthenticationVirtualMachine
 * createBaseConverter
 * createCompiler
 * createCompilerBCH
 * createCompilerCommonSynchronous
 * createIdentifierResolver
 * createInstructionSetBCH
 * createLanguage
 * createTestAuthenticationProgramBCH
 * createTransactionContextCommon
 * createTransactionContextCommonEmpty
 * createTransactionContextCommonTesting
 * cryptoOperations
 * dateToLocktime
 * dateToLocktimeBin
 * decodeBase58Address
 * decodeBase58AddressFormat
 * decodeBech32
 * decodeBitcoinSignature
 * decodeCashAddress
 * decodeCashAddressFormat
 * decodeCashAddressFormatWithoutPrefix
 * decodeCashAddressVersionByte
 * decodeHdKey
 * decodeHdPrivateKey
 * decodeHdPublicKey
 * decodePrivateKeyWif
 * decodeTransaction
 * decodeTransactionUnsafe
 * deriveHdPath
 * deriveHdPrivateNodeChild
 * deriveHdPrivateNodeFromSeed
 * deriveHdPrivateNodeIdentifier
 * deriveHdPublicNode
 * deriveHdPublicNodeChild
 * deriveHdPublicNodeIdentifier
 * describeExpectedInput
 * descriptionIsOptionalString
 * disabledOperation
 * disabledOperations
 * disassembleAuthenticationInstruction
 * disassembleBytecode
 * disassembleBytecodeBCH
 * disassembleBytecodeBTC
 * disassembleParsedAuthenticationInstruction
 * disassembleParsedAuthenticationInstructionMalformed
 * disassembleParsedAuthenticationInstructions
 * emptyHash
 * emptyRange
 * emptyReductionTraceNode
 * encodeBase58Address
 * encodeBase58AddressFormat
 * encodeBech32
 * encodeCashAddress
 * encodeCashAddressFormat
 * encodeCashAddressVersionByte
 * encodeDataPush
 * encodeHdPrivateKey
 * encodeHdPublicKey
 * encodeInput
 * encodeInputs
 * encodeOutpoints
 * encodeOutput
 * encodeOutputsForSigning
 * encodeOutputsForTransaction
 * encodePrivateKeyWif
 * encodeSequenceNumbersForSigning
 * encodeTransaction
 * equals
 * executionIsActive
 * extendCompilationDataWithScenarioBytecode
 * extendScenarioDefinition
 * extendScenarioDefinitionData
 * extendedScenarioDefinitionToCompilationData
 * extractBytecodeResolutions
 * extractEvaluationSamples
 * extractEvaluationSamplesRecursive
 * extractMissingVariables
 * extractResolvedVariableBytecodeMap
 * extractResolvedVariables
 * extractUnexecutedRanges
 * flags
 * flattenBinArray
 * formatAsmPushHex
 * formatMissingBytesAsm
 * generateBytecodeMap
 * generateDefaultScenarioDefinition
 * generateExtendedScenario
 * generatePrivateKey
 * generateScenarioCommon
 * generateSigningSerializationBCH
 * generateTransaction
 * getEmbeddedRipemd160Binary
 * getEmbeddedSecp256k1Binary
 * getEmbeddedSha1Binary
 * getEmbeddedSha256Binary
 * getEmbeddedSha512Binary
 * getFlagsForInstructionSetBCH
 * getInstructionLengthBytes
 * getResolutionErrors
 * getScenarioOutputDefaultLockingBytecode
 * getSigningSerializationType
 * getTransactionHash
 * getTransactionHashBE
 * getTransactionHashLE
 * hasMalformedLength
 * hasUnnecessaryPadding
 * hashOutputs
 * hashPrevouts
 * hashSequence
 * hexToBin
 * hmacSha256
 * hmacSha512
 * includesFlag
 * incrementOperationCount
 * instantiateBIP32Crypto
 * instantiateHmacFunction
 * instantiateRipemd160
 * instantiateRipemd160Bytes
 * instantiateRustWasm
 * instantiateSecp256k1
 * instantiateSecp256k1Bytes
 * instantiateSecp256k1Wasm
 * instantiateSecp256k1WasmBytes
 * instantiateSha1
 * instantiateSha1Bytes
 * instantiateSha256
 * instantiateSha256Bytes
 * instantiateSha512
 * instantiateSha512Bytes
 * instantiateVirtualMachineBCH
 * isAuthenticationTemplateVariableType
 * isBase64
 * isBech32CharacterSet
 * isBinString
 * isDefinedSigningSerializationType
 * isDenseArray
 * isHex
 * isHexString
 * isInteger
 * isLegacySigningSerialization
 * isLittleEndian
 * isMinimalDataPush
 * isMultiWordPush
 * isNegative
 * isObject
 * isObjectOfValidPrivateKeys
 * isPayToScriptHash
 * isPositiveInteger
 * isPushData
 * isPushOperation
 * isRangedInteger
 * isScriptNumberError
 * isStringArray
 * isStringObject
 * isValidBitLength
 * isValidCompressedPublicKeyEncoding
 * isValidInteger
 * isValidPublicKeyEncoding
 * isValidSatoshisValue
 * isValidSignatureEncodingBCHRaw
 * isValidSignatureEncodingBCHTransaction
 * isValidSignatureEncodingDER
 * isValidUncompressedPublicKeyEncoding
 * isVersion0
 * isWitnessProgram
 * lazy
 * lengthBytesForPushOpcode
 * listIds
 * lockingBytecodeToAddressContents
 * lockingBytecodeToBase58Address
 * lockingBytecodeToCashAddress
 * locktimeToDate
 * locktimeTypesAreCompatible
 * makeFailure
 * makeLineColumnIndex
 * makeSuccess
 * mapOverOperations
 * maskCashAddressPrefix
 * match
 * mergeRanges
 * mergeReplies
 * nameIsOptionalString
 * nonOperations
 * numberToBinInt16LE
 * numberToBinInt32LE
 * numberToBinInt32TwosCompliment
 * numberToBinUint16BE
 * numberToBinUint16LE
 * numberToBinUint16LEClamped
 * numberToBinUint32BE
 * numberToBinUint32LE
 * numberToBinUint32LEClamped
 * numberToBinUintLE
 * op0NotEqual
 * op1Add
 * op1Sub
 * op2Drop
 * op2Dup
 * op2Over
 * op2Rot
 * op2Swap
 * op3Dup
 * opAbs
 * opAdd
 * opAnd
 * opBin2Num
 * opBoolAnd
 * opBoolOr
 * opCat
 * opCheckDataSig
 * opCheckDataSigVerify
 * opCheckLockTimeVerify
 * opCheckMultiSig
 * opCheckMultiSigVerify
 * opCheckSequenceVerify
 * opCheckSig
 * opCheckSigVerify
 * opCodeSeparator
 * opDepth
 * opDiv
 * opDrop
 * opDup
 * opElse
 * opEndIf
 * opEqual
 * opEqualVerify
 * opFromAltStack
 * opGreaterThan
 * opGreaterThanOrEqual
 * opHash160
 * opHash256
 * opIf
 * opIfDup
 * opLessThan
 * opLessThanOrEqual
 * opMax
 * opMin
 * opMod
 * opNegate
 * opNip
 * opNop
 * opNot
 * opNotIf
 * opNum2Bin
 * opNumEqual
 * opNumEqualVerify
 * opNumNotEqual
 * opOr
 * opOver
 * opPick
 * opReturn
 * opReverseBytes
 * opRipemd160
 * opRoll
 * opRot
 * opSha1
 * opSha256
 * opSize
 * opSplit
 * opSub
 * opSwap
 * opToAltStack
 * opTuck
 * opVerify
 * opWithin
 * opXor
 * padMinimallyEncodedScriptNumber
 * parseAuthenticationTemplateEntities
 * parseAuthenticationTemplateScenarioData
 * parseAuthenticationTemplateScenarioDataHdKeys
 * parseAuthenticationTemplateScenarioDataKeys
 * parseAuthenticationTemplateScenarioTransaction
 * parseAuthenticationTemplateScenarioTransactionInputs
 * parseAuthenticationTemplateScenarioTransactionOutputLockingBytecode
 * parseAuthenticationTemplateScenarioTransactionOutputs
 * parseAuthenticationTemplateScenarios
 * parseAuthenticationTemplateScripts
 * parseAuthenticationTemplateVariable
 * parseBytecode
 * parseBytesAsScriptNumber
 * parseLocktimeBin
 * parseScript
 * pluckEndPosition
 * pluckRange
 * pluckStartPosition
 * pushNumberOperations
 * pushOperation
 * pushOperations
 * pushToStack
 * range
 * readAuthenticationInstruction
 * readBitcoinVarInt
 * readLittleEndianNumber
 * readLocktime
 * readTransactionInput
 * readTransactionOutput
 * reduceScript
 * regexp
 * regroupBits
 * removeNumericSeparators
 * reservedOperation
 * resolveScriptIdentifier
 * resolveScriptSegment
 * resolveVariableIdentifier
 * returnFailedCompilationDirective
 * safelyExtendCompilationData
 * schemaIsOptionalString
 * sepBy
 * sepBy1
 * seq
 * seqMap
 * serializeAuthenticationInstruction
 * serializeAuthenticationInstructions
 * serializeParsedAuthenticationInstruction
 * serializeParsedAuthenticationInstructionMalformed
 * serializeParsedAuthenticationInstructions
 * shouldSerializeCorrespondingOutput
 * shouldSerializeNoOutputs
 * shouldSerializeSingleInput
 * sortObjectKeys
 * spliceOperations
 * splitEvery
 * stackItemIsTruthy
 * stackOperations
 * stateIsExecuting
 * string
 * stringify
 * stringifyErrors
 * stringifyTestVector
 * succeed
 * supportsOnlyValidVmIdentifiers
 * swapEndianness
 * timeOperations
 * unconditionalFlowControlOperations
 * undefinedOperation
 * union
 * useFourStackItems
 * useOneScriptNumber
 * useOneStackItem
 * useSixStackItems
 * useThreeScriptNumbers
 * useThreeStackItems
 * useTwoScriptNumbers
 * useTwoStackItems
 * utf8ToBin
 * validateAuthenticationTemplate
 * validateSecp256k1PrivateKey
 * varIntPrefixToSize
 * verifyBtlEvaluationState
 * verifyTransaction
 * wrapSecp256k1Wasm
 * OpcodeDescriptionsBCH
 * P
 * authenticationTemplateP2pkh
 * authenticationTemplateP2pkhNonHd
 * compilerOperationsBCH
 * compilerOperationsCommon


LEGEND



Generated using TypeDoc