General purpose functions

Use acquire-module-admin to grant module admin privileges for a particular module m. You must already own admin for this particular module; that is, you must either be the owner of the keyset that grants the governance, or be able to pass the governance capability acquisition.

Assume you have some module

To grant module admin, use

It will attempt to acquire the governance cap and if successful, it will grant module admin for the rest of the transaction.

Use one of the following argument to define the value you want to retrieve using the at Pact function.

Module admin acquisition will either fail, or return "Module admin for module acquired"

See: Basic Syntax.

Use at to retrieve the value at the location specified by an index number or by a key string in a collection. If you specify an index number, the collection must be a list of values. If you specify a key string, the collection must be an object.

Because at is an overloaded function, there are two ways to use it. To get a value using the specified index location from a list of values, use the following syntax:

To get a value using the specified key string from an object, use the following syntax:

Use one of the following argument to define the value you want to retrieve using the at Pact function.

The at function returns the value found at the specified index or using the specified key.

The return value can be any data type.

The following example returns the value found at the index location—starting with 0—from a list of values. For example, the value at index location 3 is 14:

You can use the at function to return any type of data from a list. For example:

The following example returns the value found at the specified key from an object:

You can use the at function to return any type of data using the specified key from an object. For example:

Use base64-decode to convert a previously-encoded string from unpadded base64 encoding to a string.

To decode a string from unpadded base64 encoding, use the following syntax:

Use the following argument to specify the string to decode using the base64-decode Pact function.

The base64-decode function returns the decoded string.

The following example decodes a base64-encoded "aGVsbG8gd29ybGQh" string to the decoded "hello world!" string in the Pact REPL:

Use base64-encode to convert the specified string to an unpadded base64-encoded string.

To encode a string as unpadded base64, use the following syntax:

Use the following argument to specify the string to encode using the base64-encode Pact function.

The base64-encode function returns the unpadded base64 encoded string.

The following example converts the "hello world!" into the unpadded base64-encoded string "aGVsbG8gd29ybGQh" in the Pact REPL:

Use bind to evaluate a src object, then apply the specified bindings to bind field variables to values over subsequent body statements.

To evaluate src to an object and bind it with bindings over subsequent body statements, use the following syntax:

Use the following arguments to specify the src object and bindings for the bind special form.

The bind returns the result of evaluating the src object with the specifies bindings. The data type depends on the data type of the field you specify for the bindings argument.

The following example demonstrates the bind special form in the Pact REPL:

In this example, bind evaluates the object { "a": 1, "b": 2 } and binds the value of "a" to a-value. It then returns the value 1, which is the value bound to a-value.

Use chain-data to retrieve the blockchain-specific public metadata for a transaction. This function returns an object with the following fields:

To retrieve the public metadata for a transaction using chain-data, use the following syntax:

You can use the chain-data function without arguments in code that identifies the transaction that you want to return metadata for.

The chain-data function returns the public metadata for a transaction as an object with the following fields

If you call the chain-data function in the Pact REPL without providing a transaction context in the surrounding code, the function returns the object with placeholder fields. For example:

If you provide context for the call, the function returns an object with fields similar to the following:

In most cases, you use chain-data in Pact modules or in combination with frontend libraries to return information in the context of a specific transaction. The following example illustrates using chain-data in a Pact module to get the block time from a transaction:

CHARSET_ASCII is a constant used to indicate the standard ASCII character set.

(CHARSET_ASCII:integer = 0)

The CHARSET_ASCII constant represents the ASCII (American Standard Code for Information Interchange) character set, which is a widely used character encoding that includes 128 characters. It consists of control characters, digits, lowercase and uppercase English letters, and various symbols.

When working with functions or modules that require specifying a character set, you can use CHARSET_ASCII to indicate that the ASCII character set should be used.

CHARSET_LATIN1 is a constant used to indicate the standard Latin-1 (ISO-8859-1) character set.

(CHARSET_LATIN1:integer = 1)

The CHARSET_LATIN1 constant represents the Latin-1 (ISO-8859-1) character set, which is a widely used single-byte character encoding. It includes characters from various Western European languages.

When working with functions or modules that require specifying a character set, you can use CHARSET_LATIN1 to indicate that the Latin-1 character set should be used.

Use compose to compose functions where oper1 performs an operation using the specified value and oper2 takes the results from oper1 as input to produce the result for the composed function.

You can use any data type for the value argument as long as the first oper1 functions can take that same data type. By convention, the data type <a> is used to represent a type-bound parameter like the value argument in this function.

To compose a function using oper1 and oper2 with the specified value, use the following syntax:

Use the following arguments to specify the functions oper1 and oper2 for composing with value using the compose Pact function.

The compose function returns the result of applying oper2 to the result returned by oper1 for the specified value.

In the following example, compose uses the contains function to evaluate the specified list for a string, then uses the if function to operate on the results of the contains function to display the final result:

Use concat to take a list of strings str-list and concatenate each of the strings in the list, returning the resulting string.

To concatenate each string in a list, use the following syntax:

Use the following argument to specify the list of strings str-list for the concat Pact function.

The concat function returns the resulting string after concatenating all the strings in the str-list.

The following example demonstrates the concat function in the Pact REPL:

In this example, concat takes the list ["k" "d" "a"] and concatenates each string in the list, resulting in the string "kda".

The following example shows how to concatenate a list of strings after mapping each element with a function:

In this example, (str-to-list "abcde") converts the string "abcde" into a list of characters ["a" "b" "c" "d" "e"]. Then, (map (+ " ") ...) maps the function (+ " ") to each character, adding a space after each character. Finally, concat concatenates all the strings in the resulting list, producing the string "a b c d e".

Use constantly to lazily ignore the specified ignore arguments and return the specified vale.

To lazily ignore arguments and return a value, use the following syntax:

Use the following arguments to specify the value to return and the ignore arguments for the constantly Pact function.

The constantly function returns the specified value, ignoring any additional arguments.

The following example demonstrates the constantly function in the Pact REPL:

In this example, constantly true is used as the predicate function for the filter function. The constantly function always returns true and ignores the elements of the [1 2 3] list argument, so the filter function always returns the entire list.

The following example illustrate specifying multiple arguments and argument using different data types:

Use contains to test whether a list contains a value, an object has a key entry, or a string contains a substring value.

Because contains is an overloaded function, there are a few different ways to use it. To test whether a list contains a value, use the following syntax:

To test whether an object has a key entry, use the following syntax:

To test whether a string contains a substring value, use the following syntax:

Use the following arguments to specify the value, list, key, object, string for the contains Pact function.

The contains function returns a boolean value indicating whether the specified value or the specified key was found.

The following examples demonstrate the contains function in the Pact REPL.

To check whether a list contains a specified value:

In this example, the contains functions checks whether the value 2 is included in the [1 2 3] list. Because the list contains the specified value, the contains function returns true.

To check whether a specified object has 'name as a key field:

To check whether the string "foobar" contains the substring "foo",

In this example, contains "foo" "foobar" checks which it does, so it returns true.

Use continue to continue a previously-started multi-step transaction. Transactions that have multiple steps executed in a sequence are called pacts and are defined using the defpact keyword. Steps can be nested in defpact structures and the continue function enables you to continue execution with a specified value.

To continue a previously-started defpact transaction, use the following syntax:

Use the following argument to specify the value to continue the nested defpact.

The continue function continues the execution of the nested defpact with the specified value.

The following example demonstrates the use of continue within the context of a defpact to resume its execution with a specified value.

Use define-namespace to create a new namespace or update the guards of an existing namespace. The ownership and use of the namespace are controlled by the specified guards.

Note: This function can only be used at the top level of your code. It will fail if used within module code.

To define the namespace namespace, use the following syntax:

Use the following arguments to specify the namespace and guards when using the define-namespace Pact function.

The define-namespace function returns the name of the created or updated namespace as a string.

The following example creates a new namespace called 'my-namespace' with user and admin guards defined by the 'user-ks' and 'admin-ks' keysets, respectively:

Use describe-namespace to describe the specified namespace, returning a row object containing the user and admin guards of the namespace, as well as its name.

To describe the namespace namespace, use the following syntax:

You must define a namespace with the define-namespace function before you can use the describe-namespace function. For information about defining a namespace, see define-namespace.

Use the following argument to specify the namespace for the describe-namespace Pact function.

The describe-namespace function returns an object with detailed information about the specified namespace.

The following example demonstrates the describe-namespace function:

In this example, (describe-namespace 'my-namespace) is used to describe the namespace named 'my-namespace'. The function returns a row object containing the user and admin guards of the namespace, as well as its name. This provides a detailed description of the specified namespace.

Use distinct to return a list with duplicates removed from a homogeneous list of values. The original order of the values is preserved.

To return a list with duplicates removed from a list of values, use the following syntax:

Use the following argument to specify the list of VALUES for the distinct Pact function.

The distinct function returns a list with duplicates removed from the specified list of values.

The following example demonstrates how to use the distinct function to remove duplicates from a list of numeric values:

The function returns [3 1 2], preserving the original order of the values.

Use drop to remove a specified number of values from a list, string, or object.

Because drop is an overloaded function, there are two ways to use it. To remove the specified count number of values from a list or string, use the following syntax:

To remove the specified keys and corresponding values from an object or string, use the following syntax:

Use the following arguments to specify the count and list or keys and object for the drop Pact function:

The drop function returns the modified list, string, or object after removing the specified number of values or specified keys.

The following example demonstrates how to use the drop function to drop the first two characters from the specified string:

The following example illustrates how to drop the last two values from the specified list:

The following example drops the key 'name and its corresponding value from the specified object:

Use enforce-guard to execute a specified guard or a defined keyset named keysetname to enforce the predicate logic.

To use a guard to enforce specific conditions defined in predicate logic, use the following syntax:

To use a defined keyset as a guard to enforce specific conditions defined in predicate logic, use the following syntax:

Use the following arguments to specify the guard or keysetname for the enforce-guard Pact function:

The enforce-guard function returns a boolean value indicating whether the conditions specified in the predicate logic that the guard or keyset is there to enforce were met.

The following example demonstrates using the keyset guard named admin-keyset to enforce specific signing requirements defined in the keyset predicate function, for example with the keys-all or keys-2predicate:

In most cases, you use enforce-guard in the context of contract logic to ensure a specific condition is true before allowing a specific operation to be executed. For example, you might have logic to validate a sender account before allowing a transfer operation. You can then call the enforce-guard to ensure the sender meets the specified conditions—returning true as a result—before executing further logic:

Use enforce-one to run a series of tests in order (in a pure context, plus keyset enforces). If all tests fail, the transaction fails. This function short-circuits on the first successful test.

To run a series of tests in order and short-circuit on the first successful test, use the following syntax:

Use the following arguments to specify the error message and tests for the enforce-one Pact function:

The enforce-one function returns true if at least one test succeeds. If all tests fail, the function fails the transaction with the specified error message.

The following example demonstrates the enforce-one function:

In this example, (enforce-one "Should succeed on second test" [(enforce false "Skip me") (enforce (= (+ 2 2) 4) "Chaos reigns")]) is used to run two tests in order. The first test is enforce false "Skip me", which fails intentionally. The second test is (enforce (= (+ 2 2) 4) "Chaos reigns"), which succeeds because 4 = 4 is true. Because the second test succeeds, the enforce-one function returns true.

If all tests had failed, the transaction would have failed with the specified error message "Should succeed on second test".

Use enforce-pact-version to enforce the runtime Pact version to be within a specified range, where the version is greater than or equal to the min-version argument and less than or equal to the max-version argument. The max-version argument is optional.

Version values are matched numerically from the left, meaning versions like '2', '2.2', and '2.2.3' would all allow '2.2.3'.

To enforce the runtime Pact version within a specified range, use the following syntax:

Use the following arguments to specify the minimum and maximum Pact versions for the enforce-pact-version Pact function:

The enforce-pact-version function returns a boolean value indicating whether the runtime Pact version is within the specified range.

The following example demonstrates how to use the enforce-pact-version function to ensure that the runtime Pact version is at least "4.10":

If the current Pact version is "4.10" or higher, the function returns true. If the Pact version is lower than "4.10" or you specify an invalid version, the function fails.

You can also specify a maximum Pact version:

Use enforce-verifier to enforce that a verifier plugin with the specified verifier-name is in scope.

To enforce that a verifier is in scope, use the following syntax:

Use the following argument to specify the verifier-name for the enforce-verifier Pact function:

The enforce-verifier function returns a boolean value indicating whether the specified verifier is in scope.

The following example demonstrates the enforce-verifier function:

In this example, (enforce-verifier 'COOLZK) is used to enforce that the verifier named 'COOLZK' is in scope. If the verifier 'COOLZK' is in scope, the function returns true. If the verifier is not in scope, the function fails. The enforce-verifier function provides a way to ensure that a specific verifier is available for use within a Pact contract.

Use enforce to test whether a pure expression evaluates to true or false. If the specified expression evaluates to true, the function returns true. If the specified expression evaluates to false, the function fails the transaction and displays the specified error message.

To fail a transaction with a specified error message if an expression evaluates to false, use the following syntax:

Use the following arguments to specify the test expression and error message for the enforce Pact function:

The enforce function returns true if the specified expression is true. If the expression is false, the function fails the transaction with the specified error message.

The following example demonstrates how to use the enforce function to evaluate the expression (+ 2 2) != 4:

Because the specified expression (4 = 4) is true, the function returns true and the transaction continues.

If the expression were false, the transaction would fail with the error message "Chaos reigns". The enforce function provides a way to ensure conditions are met within a transaction.

Use enumerate to return a sequence of numbers from the specified first number to the specified last number, inclusively, as a list.

By default, the sequence increments by one from the first number to the last number. Optionally, you can specify an increment other than one to use between numbers in the sequence.

If you specify a first number that’s greater than the last number, the sequence decrements by one from the first number to the last number.

To increment or decrement the sequence by one, use the following syntax:

To specify a value to increment or decrement the sequence by, use the following syntax:

Use the following arguments to define the beginning and end of the sequence you want to list using the enumerate Pact function.

Use the following option to define the increment to use between the beginning and end of the sequence in the enumerate Pact function.

The enumerate function returns the resulting sequence of numbers as a list.

The following example enumerates a sequence of numbers using the default increment of one in the Pact REPL:

The following example enumerates a sequence of numbers using an increment of two between numbers in the sequence:

The following example illustrates decrementing a sequence of numbers using an inc value of -2 between numbers in the sequence:

Use filter to filter a list of elements by applying the specified apply function to each element in the list. For each element in the list, the apply function should return true or flase to identify the elements that should be included in the filtered list.

Each element that returns a result of true from the apply function is included in the resulting list with its original value. With the filter function, you can include elements in a list based on a specific condition.

To filter a list by applying a function to each element, use the following syntax:

Use the following arguments to specify the function and list for the filter Pact function:

The filter function returns a new list containing elements from the original list for which the apply function returns true.

The following example demonstrates how to use filter with a function that evaluates the length of strings to only include the strings with more than two characters:

In this example, (lambda (str) (< 2 (length str))) is used as the function that is applied to each element. This function checks the length of each element in the list. The filter function then filters the list ["my" "dog" "has" "fleas"] based on this condition. The resulting list only contains the elements that returned true when the function was applied. In this case, the resulting list is ["dog" "has" "fleas"].

In the following example, (compose (length) (= 3)) is the function applied to each element:

Like the previous example, the (compose (length) (= 3)) function checks the length of each element in the list. The filter function then filters the list based on this condition and the resulting list only contains the elements that returned true when the function was applied. In this case, the resulting list is ["red" "dog" "has"].

Use fold to iteratively reduce a list by applying the app function to the last result for each element in the list, starting with the specified init initial value.

You can use any data type for the value argument as long as the first oper1 functions can take that same data type. By convention, data type notation like <a> and <b> are used to represent type-bound parameters like the init and list arguments in this function.

To iteratively reduce a list by applying a function to each element, starting with an initial value, use the following syntax:

Use the following arguments to specify the function, initial value, and list for the fold Pact function:

The fold function returns the final result of the iterative reduction of the list.

The following example demonstrates the fold function:

In this example, (+) is used as the function to apply, which is addition in this case. The fold function starts with an initial value of 0 and iteratively adds each element of the list [100 10 5] to the previous result. Here's the breakdown:

The final result of the fold operation is 115. The fold function is commonly used for operations that require accumulating results over a list in Pact contracts.

Use format to input specified variables into a template string in the location specified using curly braces ({}) as template placeholders.

To input variables into a template string where specified by the {} placeholders, use the following syntax:

Use the following arguments to specify the template string and variables for the format Pact function:

The format function returns a new string with the values from the specified variables replacing the placeholder curly braces {} from the template string.

The following example demonstrates how to use the format function with "My {} has {}" as the template string with two {} placeholders:

In this example, the format function replaces the placeholders in the template string with the specified values ["dog", "fleas"] to return the result "My dog has fleas".

The format function is often used to create dynamic strings with variables inserted into specific locations in Pact contracts. For example, you can use the variables to store dynamic values like the current time:

Use hash-keccak256 to compute the hash of a list of unpadded base64url-encoded inputs VALUES. The hash is computed incrementally over all of the decoded inputs.

To compute the hash of a list of inputs, use the following syntax:

(hash-keccak256 VALUES)

Use the following argument to specify the list of inputs for the hash-keccak256 Pact function:

The hash-keccak256 function returns a string representing the computed hash value.

The following examples demonstrate the hash-keccak256 function:

In this example, an empty list [] is provided as input. The hash-keccak256 function computes the hash of the empty list and returns the hash value.

In this example, a list containing multiple base64url-encoded strings is provided as input. The hash-keccak256 function computes the hash of all the inputs and returns the hash value.

The hash-keccak256 function is useful for computing hash values of data for various cryptographic operations in Pact contracts.

Use hash to compute the BLAKE2b 256-bit hash of a specified value. The resulting hash value is a Base64Url-encoded string without padding. Strings values are converted directly. Other data type values are converted using their JSON representation. Non-value-level arguments are not allowed.

By convention, the data type <a> is used to represent a type-bound parameter like the value argument in this function.

To compute the BLAKE2b 256-bit hash of a value, use the following syntax:

Use the following argument to specify the value for the hash Pact function:

The hash function returns a string representing the computed hash value.

The following example demonstrates how to use the hash function to compute a hash for the "hello" string value:

Because "hello" is a string value, the hash function computes the BLAKE2b 256-bit hash of the string "hello" and returns the hash value.

In this example, { 'foo: 1 } is a JSON object. The hash function computes the BLAKE2b 256-bit hash of the JSON representation of the object and returns the hash value.

The hash function is useful for generating hash values of data for various cryptographic operations in Pact contracts.

Use identity to return the provided value.

To return the provided value, use the following syntax:

(identity value)

Use the following argument to specify the value you want to return using the identity Pact function.

The identity function returns the provided value.

The following example demonstrates the use of identity within a map function in the Pact REPL:

This example applies the identity function to each element in the list [1, 2, 3], effectively returning the same list.

Use if to test a condition. If the condition cond is true, evaluate the then expression; otherwise, evaluate the else expression.

By convention, the data type <a> is used to represent type-bound parameters that serve as input for functions and expressions or for generic arguments.

To test a condition and execute different expressions based on the result, use the following syntax:

Use the following arguments to define the condition and expressions to be evaluated based on the outcome of the condition using the if Pact function.

The if function returns the result of evaluating either the then expression or the else expression, depending on the outcome of the condition.

The following example demonstrates the use of if to test a condition in the Pact REPL:

In this example, the condition (= (+ 2 2) 4) evaluates to true, so the expression "Sanity prevails" is returned.

In this example, the condition (= (+ 2 2) 5) evaluates to false, so the expression "Chaos reigns" is returned.

Use int-to-str to represent an integer value as a string in a specified base. The base can be any integer from 2 to 16, or 64 for unpadded base64URL representation. Only positive values are allowed for base64URL conversion.

To represent an integer value as a string in a specified base, use the following syntax:

(int-to-str base val)

Use the following arguments to specify the base and integer value you want to convert using the int-to-str Pact function.

The int-to-str function returns the string representation of the integer value in the specified base.

The following examples demonstrate the use of int-to-str in the Pact REPL:

In this example, the integer value 65535 is represented as a string in base 16, resulting in "FFFF".

In this example, the integer value 43981 is represented as a string in base 64 (unpadded base64URL), resulting in "XA".

Use is-charset to check whether a string conforms to a supported character set. The character sets currently supported are CHARSET_LATIN1 (ISO-8859-1) and CHARSET_ASCII (ASCII). Support for additional sets, including those up through ISO 8859-5 supplement, will be added in the future.

To check whether a string conforms to a specified character set, use the following syntax:

(is-charset charset input)

Use the following arguments to specify the character set and input string you want to check using the is-charset Pact function.

The is-charset function returns a boolean value indicating whether the input string conforms to the specified character set.

The following examples demonstrate the use of is-charset in the Pact REPL:

In this example, the input string "hello world" conforms to the ASCII character set.

In this example, the input string "I am nÖt ascii" contains characters that are not part of the ASCII character set.

In this example, the input string "I am nÖt ascii, but I am latin1!" conforms to the ISO-8859-1 (Latin-1) character set.

Use length to return the number of elements in a list, a string, or an object.

To compute the length of a list, string, or object, use the following syntax:

Use the following argument to specify the value for which you want to compute the length using the length Pact function.

The length function returns an integer representing the length of the specified list, string, or object.

The following example demonstrates calculating the length of the list [1, 2, 3] in the Pact REPL:

The following example calculates the length of the string "abcdefgh", resulting in 8.

The following example calculates the length of the object { "a": 1, "b": 2 }, resulting in 2.

Use list-modules to list modules available for loading.

Basic syntax:

To list available modules for loading, use the following syntax:

Return value:

The list-modules function returns a list of strings representing the available modules for loading.

Examples:

The following example demonstrates the use of list-modules in the Pact REPL:

In this example, the available modules for loading are listed.

Use list to create a list from the specified elements. Note that this function is deprecated in Pact 2.1.1 with support for literal lists.

To create a list from elements, use the following syntax:

(list elems)

Use the following argument to specify the elements from which you want to create a list using the list Pact function.

The list function returns a list containing the specified elements.

The following example demonstrates the use of list in the Pact REPL:

In this example, a list containing the elements 1, 2, and 3 is created using the list function.

Use make-list to create a list by repeating a specified value a certain number of times.

To create a list by repeating a value a specified number of times, use the following syntax:

(make-list times value)

Use the following arguments to specify the length of the list and the value to be repeated using the make-list Pact function.

The make-list function returns a list containing the specified value repeated the specified number of times.

The following example demonstrates the use of make-list in the Pact REPL:

In this example, a list containing the value true repeated 5 times is created using the make-list function.

Use map to apply an application function (app) to each element in a list (list), returning a new list of results.

You can use any data type for the list argument as long as the first app function can take that same data type. By convention, data type notation like <a> and <b> are used to represent type-bound parameters that serve as input for functions and expressions or for generic arguments.

To apply an application function to each element in a list, use the following syntax:

Use the following arguments to specify the application function and the list of elements to be mapped using the map Pact function.

The map function returns a new list containing the results of applying the application function to each element in the input list.

The following example demonstrates the use of map in the Pact REPL:

In this example, the application function (+ 1) is applied to each element in the list [1 2 3], resulting in a new list [2 3 4].

Use namespace to set the current working environment to the specified namespace value. After you declare the namespace you want to work with, all of the modules and functions you define are contained within that namespace.

You can access the modules and functions in a namespace by using their fully qualified name. The fully-qualified name includes the namespace string as a prefix before the module name. For example, if you declare a principal namespace such as n_14912521e87a6d387157d526b281bde8422371d1 for the module my-calculator, you can call functions in the module using a fully-qualified name similar to the following:

n_14912521e87a6d387157d526b281bde8422371d1.my-calculator.add

If you call the namespace function after the initial declaration, Pact creates a new namespace for all subsequent declarations until either the next namespace call or the end of the transaction.

You must define a namespace before you can set your working context to use the namespace function. For information about defining a namespace, see define-namespace.

To set the current namespace to a specified value, use the following syntax:

Use the following argument to specify the namespace to be set using the namespace Pact function.

The namespace function returns the string representing the namespace that has been set.

The following example demonstrates the use of namespace in a Pact script:

In this example, the current namespace is set to 'my-namespace'. All subsequent expressions within the same transaction will be contained in this namespace until a new namespace is set or the transaction ends.

Use pact-id to return the ID if called during the current pact execution, failing if not.

To return the ID during the current pact execution, use the following syntax:

(pact-id)

The pact-id function returns a string representing the ID of the current pact execution.

The pact-id function is called without any arguments. It returns the ID if called during the current pact execution.

In this example, pact-id is called to retrieve the ID of the current pact execution.

Use pact-version to obtain the current Pact build version.

To obtain the current Pact build version, use the following syntax:

(pact-version)

The pact-version function returns a string representing the current Pact build version.

The pact-version function is called without any arguments to obtain the current Pact build version.

In this example, (pact-version) is called, which returns the current Pact build version as a string.

Use poseidon-hash-hack-a-chain to compute the Poseidon Hash Function. Note: This is a reference version of the Poseidon hash function used by Hack-a-Chain.

To compute the Poseidon Hash Function using the reference version, use the following syntax:

(poseidon-hash-hack-a-chain i j k l m n o p)

Use the following arguments to specify the inputs for computing the Poseidon hash using the poseidon-hash-hack-a-chain Pact function.

The poseidon-hash-hack-a-chain function returns an integer representing the computed Poseidon hash.

The following examples demonstrate the use of poseidon-hash-hack-a-chain in the Pact REPL:

In these examples, different sets of inputs are provided to compute the Poseidon hash using the reference version. The function returns the computed hash value as an integer.

Use read-decimal to parse a key string or number value from the top level of the message data body as a decimal.

To parse a key string as a decimal, use the following syntax:

Use the following argument to specify the key to be parsed as a decimal using the read-decimal Pact function.

The read-decimal function returns the parsed value as a decimal.

The following example demonstrates how to use the read-decimal function in a Pact script. This example parses the value specified for the amount key in the body of a message as a decimal and transfers it from one account to another:

You can also use read-decimal to read values from JSON object payloads.

Use read-integer to parse a key string or number value from the top level of the message data body as an integer.

To parse a key string as an integer, use the following syntax: