import type { XOTemplate } from '@xo-cash/types';
import { generateTemplateIdentifier } from '@xo-cash/engine';

export const p2pkhTemplate: XOTemplate = {
    $schema: 'https://libauth.org/schemas/wallet-template-v0.schema.json',

    // Name for this template.
    name: 'Wallet (P2PKH)',

    // Description for this template.
    description: 'A standard single-factor wallet template that uses Pay-to-Public-Key-Hash (P2PKH) locking scripts.',

    // Icon for this template.
    icon: 'wallet',

    // Version number for this template.
    version: 0,

    // List of VM versions that can be used to run this template.
    supported: [ 'BCH_2023_05', 'BCH_2024_05', 'BCH_2025_05', 'BCH_2026_05' ],

    // Describe a list of roles that are used in this template.
    roles: {
        owner: {
            name: 'Wallet Owner',
            description: 'The party who can spend from this wallet.',
            icon: 'owner',
        },
        receiver: {
            name: 'Receiver',
            description: 'A party that is receiving value.',
            icon: 'receiver',
        },
        sender: {
            name: 'Sender',
            description: 'A party that is sending value.',
            icon: 'sender',
        },
    },

    // Define a list of entrypoints supported by this template.
    start: [
        {
            action: 'receive',
            role: 'receiver',
        },
        {
            action: 'requestSatoshis',
            role: 'receiver',
        },
        {
            action: 'requestFungibleTokens',
            role: 'receiver',
        },
        {
            action: 'requestNonfungibleTokens',
            role: 'receiver',
        },
    ],

    // Define a list of actions that can be taken by this template.
    // NOTE: There is no action to generate an address, but a wallet can create an invitation to a receive action and
    //       extract the generated lockscript as needed as the engine will track all lockscripts it generates.
    actions: {
        receive: {
            // TODO: Consider rewriting to be generic/role-less.
            name: 'Receive',
            description: 'Receive an unspecified amount of cash and/or tokens from one or more senders.',
            icon: 'receive',

            roles: {
                receiver: {
                    name: 'Receive',
                    description: 'Receive an unspecified amount of cash and/or tokens from one or more senders.',
                    icon: 'receive',

                    requirements: {
                        generate: [ 'ownerKey' ],
                    },
                },
                sender: {
                    name: 'Send',
                    description: 'Send an unspecified amount of cash and/or tokens to the provided receiver.',
                    icon: 'send',
                },
            },

            requirements: {
                roles: [
                    {
                        role: 'receiver',
                        slots: { min: 1, max: 1 },
                    },
                    {
                        role: 'sender',
                        slots: { min: 1, max: undefined },
                    },
                ],
                variables: [ 'requestedSatoshis' ],
            },

            transaction: 'receiveTransaction',
        },
        requestSatoshis: {
            // TODO: Consider rewriting to be generic/role-less.
            name: 'Request Satoshis',
            description: 'Requests a specific amount of Bitcoin Cash from one or more senders.',
            icon: 'request',

            roles: {
                receiver: {
                    name: 'Request Satoshis',
                    description: 'Requests a specific amount of Bitcoin Cash from one or more senders.',
                    icon: 'request',

                    requirements: {
                        generate: [ 'ownerKey' ],
                        variables: [ 'requestedSatoshis' ],
                    },
                },
                sender: {
                    name: 'Send',
                    description: 'Send a specific amount of Bitcoin Cash to the provided receiver.',
                    icon: 'send',
                },
            },

            requirements: {
                roles: [
                    {
                        role: 'receiver',
                        slots: { min: 1, max: 1 },
                    },
                    {
                        role: 'sender',
                        slots: { min: 1, max: undefined },
                    },
                ],
            },

            transaction: 'requestSatoshisTransaction',
        },
        requestFungibleTokens: {
            // TODO: Consider rewriting to be generic/role-less.
            name: 'Request Fungible Tokens',
            description: 'Requests a specific amount of a fungible tokens from one or more senders.',
            icon: 'request',

            roles: {
                receiver: {
                    name: 'Request Fungible Tokens',
                    description: 'Requests a specific amount of a fungible tokens from one or more senders.',
                    icon: 'request',

                    requirements: {
                        generate: [ 'ownerKey' ],
                        variables: [ 'requestedTokenCategory', 'requestedTokenAmount' ],
                    },
                },
                sender: {
                    name: 'Send',
                    description: 'Send a specific amount of fungible tokens to the provided receiver.',
                    icon: 'send',
                },
            },

            requirements: {
                roles: [
                    {
                        role: 'receiver',
                        slots: { min: 1, max: 1 },
                    },
                    {
                        role: 'sender',
                        slots: { min: 1, max: undefined },
                    },
                ],
            },

            transaction: 'requestFungibleTokensTransaction',
        },
        requestNonfungibleTokens: {
            // TODO: Consider rewriting to be generic/role-less.
            name: 'Request a Non-fungible Token',
            description: 'Requests a non-fungible token from one or more senders.',
            icon: 'request',

            roles: {
                receiver: {
                    name: 'Request a Non-fungible Token',
                    description: 'Requests a non-fungible token from one or more senders.',
                    icon: 'request',

                    requirements: {
                        generate: [ 'ownerKey' ],
                        variables: [ 'requestedTokenCategory', 'requestedTokenCapability', 'requestedTokenCommitment' ],
                    },
                },
                sender: {
                    name: 'Send',
                    description: 'Send a non-fungible token to the provided receiver.',
                    icon: 'send',
                },
            },

            requirements: {
                roles: [
                    {
                        role: 'receiver',
                        slots: { min: 1, max: 1 },
                    },
                    {
                        role: 'sender',
                        slots: { min: 1, max: undefined },
                    },
                ],
            },

            transaction: 'requestNonfungibleTokensTransaction',
        },

        // NOTE: Sending value can be done without explicit template support.
        // NOTE: This feature is explicitly defined in this template to demonstrate how versatile templates can be, and
        //       to ensure the feature is discoverable by the user from outputs that hold value.
        sendSatoshis: {
            name: 'Send Satoshis',
            description: 'Sends a specific amount of Bitcoin Cash to a given recipient.',
            icon: 'send',

            roles: {
                sender: {
                    requirements: {
                        variables: [ 'transferredSatoshis', 'recipientLockingscript' ],
                        secrets: [ 'ownerKey' ],
                    },
                },
            },

            requirements: {
                roles: [
                    {
                        role: 'sender',
                        slots: { min: 1, max: 1 },
                    },
                ],
            },

            // Sending is only available for outputs that have sufficient satoshis on them.
            // NOTE: Dust is enforced here according to standardness rules.
            condition: '$(OP_INPUTINDEX OP_UTXOVALUE <dustLimit> OP_GREATERTHAN)',

            transaction: 'transferSatoshisTransaction',
        },
        sendFungibleTokens: {
            name: 'Send Fungible Tokens',
            description: 'Send a specific amount of a fungible token to a given recipient.',
            icon: 'send',

            roles: {
                sender: {
                    requirements: {
                        variables: [ 'transferredTokenCategory', 'transferredTokenAmount', 'recipientLockingscript' ],
                        secrets: [ 'ownerKey' ],
                    },
                },
            },

            requirements: {
                roles: [
                    {
                        role: 'sender',
                        slots: { min: 1, max: 1 },
                    },
                ],
            },

            // Sending is only available for outputs that have fungible tokens on them.
            condition: '$(OP_INPUTINDEX OP_UTXOTOKENAMOUNT <0> OP_GREATERTHAN)',

            transaction: 'transferFungibleTokensTransaction',
        },
        sendNonfungibleTokens: {
            name: 'Send a Non-fungible Token',
            description: 'Send a non-fungible token to a given recipient.',
            icon: 'send',

            roles: {
                sender: {
                    requirements: {
                        variables: [ 'transferredTokenCategory', 'transferredTokenCapability', 'transferredTokenCommitment', 'recipientLockingscript' ],
                        secrets: [ 'ownerKey' ],
                    },
                },
            },

            requirements: {
                roles: [
                    {
                        role: 'sender',
                        slots: { min: 1, max: 1 },
                    },
                ],
            },

            // Sending is only available for outputs that have a non-fungible token on them.
            condition: '$(OP_INPUTINDEX OP_UTXOTOKENCATEGORY OP_SIZE OP_NIP <32> OP_GREATERTHAN)',

            transaction: 'transferNonfungibleTokensTransaction',
        },

        // NOTE: Burning tokens can be done without explicit template support.
        // NOTE: This feature is explicitly defined in this template to demonstrate how versatile templates can be, and
        //       to ensure the feature is discoverable by the user from outputs that hold tokens.
        burnFungibleTokens: {
            name: 'Delete Fungible Tokens',
            description: 'Permanently and irreversibly deletes one or more fungible tokens.',
            icon: 'burn',

            roles: {
                owner: {
                    requirements: {
                        variables: [ 'burnedTokenCategory', 'burnedTokenAmount' ],
                        secrets: [ 'ownerKey' ],
                    },
                },
            },

            requirements: {
                roles: [
                    {
                        role: 'owner',
                        slots: { min: 1, max: 1 },
                    },
                ],
            },

            // Burning is only available for outputs that have fungible tokens on them.
            condition: '$(OP_INPUTINDEX OP_UTXOTOKENAMOUNT <0> OP_GREATERTHAN)',

            transaction: 'burnFungibleTokensTransaction',
        },
        burnNonfungibleTokens: {
            name: 'Delete a Non-fungible Token',
            description: 'Permanently and irreversibly deletes one non-fungible token.',
            icon: 'burn',

            roles: {
                owner: {
                    requirements: {
                        variables: [ 'burnedTokenCategory', 'burnedTokenCapability', 'burnedTokenCommitment' ],
                        secrets: [ 'ownerKey' ],
                    },
                },
            },

            requirements: {
                roles: [
                    {
                        role: 'owner',
                        slots: { min: 1, max: 1 },
                    },
                ],
            },

            // Burning is only available for outputs that have non-fungible tokens on them.
            condition: '$(OP_INPUTINDEX OP_UTXOTOKENCATEGORY OP_SIZE OP_NIP <32> OP_GREATERTHAN)',

            transaction: 'burnNonfungibleTokenTransaction',
        },

        sign: {
            name: 'Sign Message',
            description: 'Signs a provided message using the Bitcoin message signing protocol.',
            icon: 'sign',

            roles: {
                owner: {
                    requirements: {
                        variables: [ 'messageToSign' ],
                        secrets: [ 'ownerKey' ],
                    },
                },
            },

            requirements: {
                roles: [
                    {
                        role: 'owner',
                        slots: { min: 1, max: 1 },
                    },
                ],
            },

            data: [ 'messageSignature' ],
        },
        verify: {
            name: 'Verify Message Signature',
            description: 'Verifies a provided message signature according to the Bitcoin message signing protocol.',
            icon: 'verify',

            roles: {
                owner: {
                    requirements: {
                        variables: [ 'messageSignature', 'messageToVerify' ],
                        secrets: [ 'ownerKey' ],
                    },
                },
            },

            requirements: {
                roles: [
                    {
                        role: 'owner',
                        slots: { min: 1, max: 1 },
                    },
                ],
            },

            data: [ 'messageSignatureValidity' ],
        },
    },

    // Define a set of data that can be used in this template.
    data: {
        messageSignature: {
            // Evaluate CashASM expression to get the signature needed.
            // NOTE: Pushes the prefix and message, then concatenates them together to form the data to sign.
            // NOTE: In libauth today, it seems that this is done by defining the signature as a variable, and tying it to the key and message,
            // and so this is different
            // TODO: Check with Jason and see if there is any reason why this cannot be done like this.
            value: '$(<messagePrefix> <message> OP_CAT <ownerKey.data_signature.top_stack_element>)',
            type: 'bytes',
            hint: 'signature',
        },
        messageSignatureValidity: {
            // Evaluate the validity of the message with the owners public key.
            value: '$(<messageSignature> <messagePrefix> <message> OP_CAT <ownerKey.public_key> OP_CHECKDATASIG)',
            type: 'integer',
            hint: 'script_boolean',
        },
    },

    // Define a set of transactions that can be used in this template.
    transactions: {
        receiveTransaction: {
            name: 'Transfer request',
            description: 'Transfer request for an unspecified amount of cash and/or tokens.',
            icon: 'request',

            roles: {
                receiver: {
                    name: 'Received',
                    description: 'Received an unspecified amount of cash and/or tokens.',
                    icon: 'receive',
                },
                sender: {
                    name: 'Sent',
                    description: 'Sent an unspecified amount of cash and/or tokens.',
                    icon: 'send',
                },
            },

            // Inputs and outputs that must exist in the transaction.
            // NOTE: There is no inputs required, but the engine should detect that there is not sufficient input value to
            //       match the output and thus generate an invitation to participate in this action.
            //       When the invitation is shared, the other parties can add as many inputs and change outputs as needed.
            inputs: [],
            outputs: [
                {
                    output: 'receiveOutput',
                    index: undefined,
                },
            ],

            // Standard transaction without a locktime.
            version: 2,
            locktime: 0,

            // ...
            composable: true,
        },
        requestSatoshisTransaction: {
            name: 'Transfer request',
            description: 'Transfer request for $(<requestedSatoshis>) satoshis.',
            icon: 'request',

            roles: {
                receiver: {
                    name: 'Received',
                    description: 'Received $(<requestedSatoshis>) satoshis.',
                    icon: 'receive',
                },
                sender: {
                    name: 'Sent',
                    description: 'Sent $(<requestedSatoshis>) satoshis.',
                    icon: 'send',
                },
            },

            // Inputs and outputs that must exist in the transaction.
            // NOTE: There is no inputs required, but the engine should detect that there is not sufficient input value to
            //       match the output and thus generate an invitation to participate in this action.
            //       When the invitation is shared, the other party can add as many inputs and outputs as needed since this transaction is composable.
            inputs: [],
            outputs: [
                {
                    output: 'requestSatoshisOutput',
                    index: undefined,
                },
            ],

            // Standard transaction without a locktime.
            version: 2,
            locktime: 0,

            // ...
            composable: true,
        },
        requestFungibleTokensTransaction: {
            name: 'Transfer request',
            description:
                'Transfer request for $(<requestedTokenAmount> <requestedTokenCategory.decimalsFactor> OP_DIV).$(<requestedTokenAmount> <requestedTokenCategory.decimalsFactor> OP_MOD) $(<requestedTokenCategory.symbol>) tokens.',
            icon: 'request',

            roles: {
                receiver: {
                    name: 'Received',
                    description:
                        'Received $(<requestedTokenAmount> <requestedTokenCategory.decimalsFactor> OP_DIV).$(<requestedTokenAmount> <requestedTokenCategory.decimalsFactor> OP_MOD) $(<requestedTokenCategory.symbol>) tokens.',
                    icon: 'receive',
                },
                sender: {
                    name: 'Sent',
                    description:
                        'Sent $(<requestedTokenAmount> <requestedTokenCategory.decimalsFactor> OP_DIV).$(<requestedTokenAmount> <requestedTokenCategory.decimalsFactor> OP_MOD) $(<requestedTokenCategory.symbol>) tokens.',
                    icon: 'send',
                },
            },

            // Inputs and outputs that must exist in the transaction.
            // NOTE: There is no inputs required, but the engine should detect that there is not sufficient input value to
            //       match the output and thus generate an invitation to participate in this action.
            //       When the invitation is shared, the other party can add as many inputs and outputs as needed since this transaction is composable.
            inputs: [],
            outputs: [
                {
                    output: 'requestFungibleTokensOutput',
                    index: undefined,
                },
            ],

            // Standard transaction without a locktime.
            version: 2,
            locktime: 0,

            // ...
            composable: true,
        },
        requestNonfungibleTokensTransaction: {
            name: 'Transfer request',
            description:
                'Transfer request for one non-fungible $(<requestedTokenCapability> <0x02> OP_EQUAL OP_IF <"minting"> OP_ELSE <requestedTokenCapability> <0x01> OP_EQUAL OP_IF <"mutable"> OP_ELSE <"immutable"> OP_ENDIF OP_ENDIF) (<requestedTokenCategory.symbol>) token, with $(<requestedTokenCommitment>) commitment.',
            icon: 'request',

            roles: {
                receiver: {
                    name: 'Received',
                    description:
                        'Received one non-fungible $(<requestedTokenCapability> <0x02> OP_EQUAL OP_IF <"minting"> OP_ELSE <requestedTokenCapability> <0x01> OP_EQUAL OP_IF <"mutable"> OP_ELSE <"immutable"> OP_ENDIF OP_ENDIF) (<requestedTokenCategory.symbol>) token, with $(<requestedTokenCommitment>) commitment.',
                    icon: 'receive',
                },
                sender: {
                    name: 'Sent',
                    description:
                        'Sent the requested non-fungible $(<requestedTokenCapability> <0x02> OP_EQUAL OP_IF <"minting"> OP_ELSE <requestedTokenCapability> <0x01> OP_EQUAL OP_IF <"mutable"> OP_ELSE <"immutable"> OP_ENDIF OP_ENDIF) (<requestedTokenCategory.symbol>) token, with $(<requestedTokenCommitment>) commitment.',
                    icon: 'send',
                },
            },

            // Inputs and outputs that must exist in the transaction.
            // NOTE: There is no inputs required, but the engine should detect that there is not sufficient input value to
            //       match the output and thus generate an invitation to participate in this action.
            //       When the invitation is shared, the other party can add as many inputs and outputs as needed since this transaction is composable.
            inputs: [],
            outputs: [
                {
                    output: 'requestNonfungibleTokensOutput',
                    index: undefined,
                },
            ],

            // Standard transaction without a locktime.
            version: 2,
            locktime: 0,

            // ...
            composable: true,
        },

        transferSatoshisTransaction: {
            name: 'Satoshis Transferred',
            description: '$(<transferredSatoshis>) satoshis were transferred to a recipient.',
            icon: 'send',

            roles: {
                receiver: {
                    name: 'Received',
                    description: 'Received $(<transferredSatoshis>) satoshis.',
                    icon: 'receive',
                },
                sender: {
                    name: 'Sent',
                    description: 'Sent $(<transferredSatoshis>) satoshis.',
                    icon: 'send',
                },
            },

            // Enforce the inputs and outputs required by the transaction.
            // NOTE: The input is provided from the action since it is only available on outputs with satoshis.
            inputs: [],
            outputs: [
                {
                    output: 'transferSatoshisOutput',
                    index: undefined,
                },
            ],

            // Standard transaction without a locktime.
            version: 2,
            locktime: 0,

            // ...
            composable: true,
        },
        transferFungibleTokensTransaction: {
            name: 'Fungible Tokens Transferred',
            description:
                '$(<transferredTokenAmount> <transferredTokenCategory.decimalsFactor> OP_DIV).$(<transferredTokenAmount> <transferredTokenCategory.decimalsFactor> OP_MOD) $(<transferredTokenCategory.symbol>) tokens were transferred to a recipient.',
            icon: 'send',

            roles: {
                receiver: {
                    name: 'Received',
                    description:
                        'Received $(<transferredTokenAmount> <transferredTokenCategory.decimalsFactor> OP_DIV).$(<transferredTokenAmount> <transferredTokenCategory.decimalsFactor> OP_MOD) $(<transferredTokenCategory.symbol>) tokens.',
                    icon: 'receive',
                },
                sender: {
                    name: 'Sent',
                    description:
                        'Sent $(<transferredTokenAmount> <transferredTokenCategory.decimalsFactor> OP_DIV).$(<transferredTokenAmount> <transferredTokenCategory.decimalsFactor> OP_MOD) $(<transferredTokenCategory.symbol>) tokens.',
                    icon: 'send',
                },
            },

            // Enforce the inputs and outputs required by the transaction.
            // NOTE: The input is provided from the action since it is only available on outputs with fungible tokens.
            inputs: [],
            outputs: [
                {
                    output: 'transferFungibleTokensOutput',
                    index: undefined,
                },
            ],

            // Standard transaction without a locktime.
            version: 2,
            locktime: 0,

            // ...
            composable: true,
        },
        transferNonfungibleTokensTransaction: {
            name: 'Non-fungible Token Transferred',
            description:
                'One non-fungible $(<transferredTokenCapability> <0x02> OP_EQUAL OP_IF <"minting"> OP_ELSE <transferredTokenCapability> <0x01> OP_EQUAL OP_IF <"mutable"> OP_ELSE <"immutable"> OP_ENDIF OP_ENDIF) $(<transferredTokenCategory.symbol>) token was transferred to a recipient, with $(<transferredTokenCommitment>) commitment.',
            icon: 'send',

            roles: {
                receiver: {
                    name: 'Received',
                    description:
                        'Received one non-fungible $(<transferredTokenCapability> <0x02> OP_EQUAL OP_IF <"minting"> OP_ELSE <transferredTokenCapability> <0x01> OP_EQUAL OP_IF <"mutable"> OP_ELSE <"immutable"> OP_ENDIF OP_ENDIF) (<transferredTokenCategory.symbol>) token, with $(<transferredTokenCommitment>) commitment.',
                    icon: 'receive',
                },
                sender: {
                    name: 'Sent',
                    description:
                        'Sent one non-fungible $(<transferredTokenCapability> <0x02> OP_EQUAL OP_IF <"minting"> OP_ELSE <transferredTokenCapability> <0x01> OP_EQUAL OP_IF <"mutable"> OP_ELSE <"immutable"> OP_ENDIF OP_ENDIF) (<transferredTokenCategory.symbol>) token, with $(<transferredTokenCommitment>) commitment.',
                    icon: 'send',
                },
            },

            // Enforce the inputs and outputs required by the transaction.
            // NOTE: The input is provided from the action since it is only available on outputs with a non-fungible token.
            inputs: [],
            outputs: [
                {
                    output: 'transferNonfungibleTokenOutput',
                    index: undefined,
                },
            ],

            // Standard transaction without a locktime.
            version: 2,
            locktime: 0,

            // ...
            composable: true,
        },

        burnFungibleTokensTransaction: {
            name: 'Deleted fungible tokens',
            description:
                'Permanently and irreversibly deleted $(<burnedTokenAmount> <burnedTokenCategory.decimalsFactor> OP_DIV).$(<burnedTokenAmount> <burnedTokenCategory.decimalsFactor> OP_MOD) $(<burnedTokenCategory.symbol>) tokens.',
            icon: 'burn',

            // Inputs and outputs that must exist in the transaction.
            // NOTE: There is no defined outputs as any non-burned value is automatically returned as change.
            inputs: [
                {
                    input: 'burnFungibleTokensInput',
                    index: undefined,
                },
            ],

            outputs: [],

            // Standard transaction without a locktime.
            version: 2,
            locktime: 0,

            // ...
            composable: true,
        },
        burnNonfungibleTokenTransaction: {
            name: 'Deleted non fungible token',
            description:
                'Permanently and irreversibly deleted a non-fungible $(<burnedTokenCapability> <0x02> OP_EQUAL OP_IF <"minting"> OP_ELSE <burnedTokenCapability> <0x01> OP_EQUAL OP_IF <"mutable"> OP_ELSE <"immutable"> OP_ENDIF OP_ENDIF) (<burnedTokenCategory.symbol>) token, with $(<burnedTokenCommitment>) commitment.',
            icon: 'burn',

            // Inputs and outputs that must exist in the transaction.
            // NOTE: There is no defined outputs as any non-burned value is automatically returned as change.
            inputs: [
                {
                    input: 'burnNonfungibleTokenInput',
                    index: undefined,
                },
            ],
            outputs: [],

            // Standard transaction without a locktime.
            version: 2,
            locktime: 0,

            // ...
            composable: true,
        },
    },

    // Define a set of outputs that can be used within transactions in this template.
    outputs: {
        receiveOutput: {
            name: 'Recipient output',
            description: 'Transferred an unspecified amount of cash and/or tokens to a recipient.',
            icon: 'receive',

            roles: {
                receiver: {
                    name: 'Received',
                    description: 'Received an unspecified amount of cash and/or tokens.',
                },
                sender: {
                    name: 'Sent',
                    description: 'Sent an unspecified amount of cash and/or tokens.',
                },
            },

            // Defines how the requested funds should be locked.
            lockscript: 'receivingLockingScript',
        },
        requestSatoshisOutput: {
            name: 'Recipient output',
            description: 'Transferred $(<requestedSatoshis>) satoshis to a recipient.',
            icon: 'request',

            roles: {
                receiver: {
                    name: 'Received',
                    description: 'Received $(<requestedSatoshis>) satoshis.',
                },
                sender: {
                    name: 'Sent',
                    description: 'Sent $(<requestedSatoshis>) satoshis.',
                },
            },

            // Defines how the requested funds should be locked.
            lockscript: 'receivingLockingScript',

            // Require the specified number of satoshis and no tokens.
            valueSatoshis: '$(<requestedSatoshis>)',
            token: null,
        },
        requestFungibleTokensOutput: {
            name: 'Recipient output',
            description:
                'Transferred $(<requestedTokenAmount> <requestedTokenCategory.decimalsFactor> OP_DIV).$(<requestedTokenAmount> <requestedTokenCategory.decimalsFactor> OP_MOD) $(<requestedTokenCategory.symbol>) tokens to a recipient.',
            icon: 'request',

            roles: {
                receiver: {
                    name: 'Received',
                    description:
                        'Received $(<requestedTokenAmount> <requestedTokenCategory.decimalsFactor> OP_DIV).$(<requestedTokenAmount> <requestedTokenCategory.decimalsFactor> OP_MOD) $(<requestedTokenCategory.symbol>) tokens.',
                },
                sender: {
                    name: 'Sent',
                    description:
                        'Sent $(<requestedTokenAmount> <requestedTokenCategory.decimalsFactor> OP_DIV).$(<requestedTokenAmount> <requestedTokenCategory.decimalsFactor> OP_MOD) $(<requestedTokenCategory.symbol>) tokens.',
                },
            },

            // Defines how the requested funds should be locked.
            lockscript: 'receivingLockingScript',

            // Require a flat 1000 satoshis to ensure the fungible tokens remains transferrable.
            valueSatoshis: '1000',

            // Require only the specified amount and type of fungible tokens.
            // NOTE: This can be composed with a request for a non-fungible token, but will always result in two separate outputs.
            token: {
                category: '$(<requestedTokenCategory>)',
                amount: '$(<requestedTokenAmount>)',
                nft: null,
            },
        },
        requestNonfungibleTokensOutput: {
            name: 'Recipient output',
            description:
                'Transferred one non-fungible $(<requestedTokenCapability> <0x02> OP_EQUAL OP_IF <"minting"> OP_ELSE <requestedTokenCapability> <0x01> OP_EQUAL OP_IF <"mutable"> OP_ELSE <"immutable"> OP_ENDIF OP_ENDIF) $(<requestedTokenCategory.symbol>) token to a recipient, with $(<requestedTokenCommitment>) commitment.',
            icon: 'request',

            roles: {
                receiver: {
                    name: 'Received',
                    description:
                        'Received one non-fungible $(<requestedTokenCapability> <0x02> OP_EQUAL OP_IF <"minting"> OP_ELSE <requestedTokenCapability> <0x01> OP_EQUAL OP_IF <"mutable"> OP_ELSE <"immutable"> OP_ENDIF OP_ENDIF) $(<requestedTokenCategory.symbol>) token, with $(<requestedTokenCommitment>) commitment.',
                },
                sender: {
                    name: 'Sent',
                    description:
                        'Sent the requested non-fungible $(<requestedTokenCapability> <0x02> OP_EQUAL OP_IF <"minting"> OP_ELSE <requestedTokenCapability> <0x01> OP_EQUAL OP_IF <"mutable"> OP_ELSE <"immutable"> OP_ENDIF OP_ENDIF) $(<requestedTokenCategory.symbol>) token, with $(<requestedTokenCommitment>) commitment.',
                },
            },

            // Defines how the requested funds should be locked.
            lockscript: 'receivingLockingScript',

            // Require a flat 1000 satoshis to ensure the non-fungible token remains transferrable.
            valueSatoshis: '1000',

            // Require only an NFT with specified category, capability and commitment.
            // NOTE: This can be composed with a request for fungible token amounts, but will always result in two separate outputs.
            token: {
                category: '$(<requestedTokenCategory>)',
                amount: null,
                nft: {
                    capability: '$(<requestedTokenCapability>)',
                    commitment: '$(<requestedTokenCommitment>)',
                },
            },
        },

        transferSatoshisOutput: {
            name: 'Recipient output',
            description: 'Transferred $(<transferredSatoshis>) satoshis to a recipient.',
            icon: 'send',

            roles: {
                receiver: {
                    name: 'Received',
                    description: 'Received $(<transferredSatoshis>) satoshis.',
                },
                sender: {
                    name: 'Sent',
                    description: 'Sent $(<transferredSatoshis>) satoshis.',
                },
            },

            // Use the recipients lockscript.
            lockscript: 'sendingLockingscript',

            // Set the amount of satoshis to transfer.
            valueSatoshis: '$(<transferredSatoshis>)',
        },
        transferFungibleTokensOutput: {
            name: 'Recipient output',
            description:
                'Transferred $(<transferredTokenAmount> <transferredTokenCategory.decimalsFactor> OP_DIV).$(<transferredTokenAmount> <transferredTokenCategory.decimalsFactor> OP_MOD) $(<transferredTokenCategory.symbol>) tokens to a recipient.',
            icon: 'send',

            roles: {
                receiver: {
                    name: 'Received',
                    description:
                        'Received $(<transferredTokenAmount> <transferredTokenCategory.decimalsFactor> OP_DIV).$(<transferredTokenAmount> <transferredTokenCategory.decimalsFactor> OP_MOD) $(<transferredTokenCategory.symbol>) tokens.',
                },
                sender: {
                    name: 'Sent',
                    description:
                        'Sent $(<transferredTokenAmount> <transferredTokenCategory.decimalsFactor> OP_DIV).$(<transferredTokenAmount> <transferredTokenCategory.decimalsFactor> OP_MOD) $(<transferredTokenCategory.symbol>) tokens.',
                },
            },

            // Use the recipients lockscript.
            lockscript: 'sendingLockingscript',

            // Set the amount of fungible tokens to transfer.
            token: {
                category: '$(<transferredTokenCategory>)',
                amount: '$(<transferredTokenAmount>)',
            },
        },
        transferNonfungibleTokenOutput: {
            name: 'Recipient output',
            description:
                'Transferred one non-fungible $(<transferredTokenCapability> <0x02> OP_EQUAL OP_IF <"minting"> OP_ELSE <transferredTokenCapability> <0x01> OP_EQUAL OP_IF <"mutable"> OP_ELSE <"immutable"> OP_ENDIF OP_ENDIF) $(<transferredTokenCategory.symbol>) token to a recipient, with $(<transferredTokenCommitment>) commitment.',
            icon: 'send',

            roles: {
                receiver: {
                    name: 'Received',
                    description:
                        'Received one non-fungible $(<transferredTokenCapability> <0x02> OP_EQUAL OP_IF <"minting"> OP_ELSE <transferredTokenCapability> <0x01> OP_EQUAL OP_IF <"mutable"> OP_ELSE <"immutable"> OP_ENDIF OP_ENDIF) $(<transferredTokenCategory.symbol>) token, with $(<transferredTokenCommitment>) commitment.',
                },
                sender: {
                    name: 'Sent',
                    description:
                        'Sent one non-fungible $(<transferredTokenCapability> <0x02> OP_EQUAL OP_IF <"minting"> OP_ELSE <transferredTokenCapability> <0x01> OP_EQUAL OP_IF <"mutable"> OP_ELSE <"immutable"> OP_ENDIF OP_ENDIF) $(<transferredTokenCategory.symbol>) token, with $(<transferredTokenCommitment>) commitment.',
                },
            },

            // Use the recipients lockscript.
            lockscript: 'sendingLockingscript',

            // Set the non-fungible token to transfer.
            token: {
                category: '$(<transferredTokenCategory>)',
                nft: {
                    capability: '$(<transferredTokenCapability>)',
                    commitment: '$(<transferredTokenCommitment>)',
                },
            },
        },
    },

    inputs: {
        burnFungibleTokensInput: {
            name: 'Deleted fungible tokens',
            description: 'Permanently and irreversibly deleted $(<burnedTokenAmount>) $(<burnedTokenCategory>).',
            icon: 'burn',

            // Define which unlocking script unlocks this input.
            unlockingScript: 'unlockP2PKH',

            // Require a fungible token of the requested token category, with an amount larger than or equal to the requested amount to burn.
            token: {
                category: '$(<burnedTokenCategory>)',
                amount: '$(<this.fungibleTokenAmount> <burnedTokenAmount> OP_GREATERTHANOREQUAL OP_IF <this.fungibleTokens> OP_ENDIF)',
            },

            // Ignore the burned token amount when determining change for this output.
            // NOTE: The engine must check that this does not exceed the input value.
            omitChangeAmounts: {
                fungibleTokens: '${<burnedTokenAmount>}',
            },
        },
        burnNonfungibleTokenInput: {
            name: 'Deleted non-fungible token',
            description:
                'Permanently and irreversibly burned one non-fungible $(<burnedTokenCapability> <0x02> OP_EQUAL OP_IF <"minting"> OP_ELSE <burnedTokenCapability> <0x01> OP_EQUAL OP_IF <"mutable"> OP_ELSE <"immutable"> OP_ENDIF OP_ENDIF) token of category $(<burnedTokenCategory>), with a $(<burnedTokenCommitment>) commitment.',
            icon: 'burn',

            // Define which unlocking script unlocks this input.
            unlockingScript: 'unlockP2PKH',

            // Require a non-fungible token of the specified category, capability and commitment to burn.
            token: {
                category: '$(<burnedTokenCategory>)',
                nft: {
                    capability: '$(<burnedTokenCapability>)',
                    commitment: '$(<burnedTokenCommitment>)',
                },
            },

            // Ignore the burned token when determining change for this output.
            // NOTE: The engine must check that this does not exceed the input value.
            omitChangeAmounts: {
                nonfungibleTokens: 1,
            },
        },
    },

    // Define locking scripts used by this template.
    // NOTE: Template supported wallets should automatically track all generated lockscripts for on-chain events.
    lockingScripts: {
        sendingLockingscript: {
            // TODO: This currently describes outputs locked to this script, but all actions creating such outputs already have descriptions.
            // This can either be dropped, or maybe more importantly, should be disambiguated so that lockscripts can provide separate
            // descriptions for their script and the outputs that are locked to them. Leaving as a TODO for now and will address later.
            name: 'Sent',
            description: 'Funds sent to an external recipient',
            icon: 'address',

            // ...
            lockingType: 'standard',
            lockingScript: 'lockToRecipient',

            // Indicate that the sent output does not belong to the initiating user.
            // NOTE: These values default to false/empty, but added here for additional clarity.
            actions: [],
            state: [],
            secrets: [],
            balance: false,
            selectable: false,
            privacy: false,
        },
        receivingLockingScript: {
            // NOTE: Outputs to this lockscript by external actors defaults to this description when detected on-chain.
            name: 'Received',
            description: 'Funds received without wallet coordination.',
            icon: 'address',

            // Defines how spending future received funds should be locked.
            lockingType: 'standard',
            lockingScript: 'lockP2PKH',

            // Define a default unlocking script to be used when no action provided script is present.
            unlockingScript: 'unlockP2PKH',

            roles: {
                receiver: {
                    // The only state that is required to be persisted when receiving funds is the owners private key.
                    // NOTE: This is defined as a secret to not leak when creating invitations for others to participate in request or send actions.
                    state: {
                        variables: [],
                        secrets: [ 'ownerKey' ],
                    },

                    // List actions that can be taken with the ownerKey for each address/lockscript.
                    actions: [
                        {
                            action: 'sign',
                            role: 'owner',
                            secrets: [ 'ownerKey' ],
                        },
                        {
                            action: 'verify',
                            role: 'owner',
                            secrets: [ 'ownerKey' ],
                        },
                        {
                            action: 'sendSatoshis',
                            role: 'sender',
                            secrets: [ 'ownerKey' ],
                        },
                        {
                            action: 'sendFungibleTokens',
                            role: 'sender',
                            secrets: [ 'ownerKey' ],
                        },
                        {
                            action: 'sendNonfungibleTokens',
                            role: 'sender',
                            secrets: [ 'ownerKey' ],
                        },
                        {
                            action: 'burnFungibleTokens',
                            role: 'sender',
                            secrets: [ 'ownerKey' ],
                        },
                        {
                            action: 'burnNonfungibleTokens',
                            role: 'sender',
                            secrets: [ 'ownerKey' ],
                        },
                    ],

                    // Indicates how much of received funds should be part of a wallets total balance.
                    // NOTE: Evaluates in the context of the source transaction, with the current outputs technical data available under this.output.*
                    // NOTE: This can either evaluate to a boolean or a number. If evaluated to a boolean, then true means 100% of the output.
                    // NOTE: Since we know that the owner controls all assets, we short-cut the evaluations by setting true directly.
                    balance: {
                        satoshis: true,
                        fungibleTokens: true,
                        // nonFungibleToken: true,
                    },

                    // Indicate when received funds should be considered in automatic coin selection to meet input requirements of other transactions.
                    // NOTE: Evaluates in the context of the source transaction, with the current outputs technical data available under this.output.*
                    // NOTE: This evaluates to a boolean. If non-true, the output should not be considered for automatic coin selection.
                    // NOTE: Since we know that the secret key exist for the owner, this template short-cuts the evaluation by setting true directly.
                    selectable: true,

                    // Indicate that received funds are not considered good privacy.
                    // NOTE: This information allows wallets to make better privacy decisions, like avoid mixing private and non-private outputs.
                    privacy: false,
                },
            },
        },
    },

    // Define a set of scripts that can be used in this template.
    scripts: {
        lockP2PKH: 'OP_DUP OP_HASH160 <$(<ownerKey.public_key> OP_HASH160)> OP_EQUALVERIFY OP_CHECKSIG',
        unlockP2PKH: '<ownerKey.schnorr_signature.all_outputs> <ownerKey.public_key>',
        lockToRecipient: '<recipientLockingscript>',
    },

    // TODO: Add icons
    constants: {
        dustLimit: {
            name: 'Dust Limit',
            description: 'Standard required minimum satoshis for Pay to Public Key Hash outputs.',
            type: 'integer',
            value: 546,
        },

        // Define a message prefix for use in arbitrary message signing.
        messagePrefix: {
            name: 'Message Prefix',
            description: 'Standard message prefix used in the bitcoin signed message protocol.',
            type: 'bytes',

            // Value is enforced to the bitcoin signing magic string:
            // "\x18Bitcoin Signed Message:\n"
            value: '0x18426974636f696e205369676e6564204d6573736167653a0a',
        },
    },

    // TODO: Add icons
    variables: {
        // Describe the secret private key.
        ownerKey: {
            name: 'Owners Private Key',
            description: 'The private key used to authorize spending of received funds.',
            type: 'bytes',
            hint: 'private_key',
        },

        messageToSign: {
            name: 'Message',
            description: 'The text message to sign.',
            type: 'string',
        },
        messageToVerify: {
            name: 'Message',
            description: 'The text message to verify.',
            type: 'string',
        },
        messageSignature: {
            name: 'Message Signature',
            description: 'The signature for the message.',
            type: 'bytes',
            hint: 'signature',
        },

        // Describe the parameters used when requesting value.
        requestedSatoshis: {
            name: 'Requested Amount',
            description: 'The Bitcoin Cash amount requested',
            type: 'integer',
            hint: 'satoshis',
        },
        requestedTokenCategory: {
            name: 'Requested Token Category',
            description: 'The token category requested',
            type: 'bytes',
            hint: 'token_category',
        },
        requestedTokenAmount: {
            name: 'Requested Token Amount',
            description: 'The fungible token amount requested',
            type: 'integer',
            hint: 'token_amount',
        },
        requestedTokenCapability: {
            name: 'Requested Token Capability',
            description: 'The non-fungible token capability requested',
            type: 'bytes',
            hint: 'token_capability',
        },
        requestedTokenCommitment: {
            name: 'Requested Token Commitment',
            description: 'The non-fungible token commitment requested',
            type: 'bytes',
            hint: 'token_commitment',
        },
        transferredTokenCategory: {
            name: 'Sending Token Category',
            description: 'The token category of the token(s) to send',
            type: 'bytes',
            hint: 'token_category',
        },
        transferredTokenAmount: {
            name: 'Sending Token Amount',
            description: 'The fungible token amount to send',
            type: 'integer',
            hint: 'token_amount',
        },
        transferredTokenCapability: {
            name: 'Sending Token Capability',
            description: 'The token capability for the non-fungible token to send',
            type: 'bytes',
            hint: 'token_capability',
        },
        transferredTokenCommitment: {
            name: 'Sending Token Commitment',
            description: 'The token commitment for the non-fungible token to send',
            type: 'bytes',
            hint: 'token_commitment',
        },
        burnedTokenCategory: {
            name: 'Deleted Token Category',
            description: 'The token category of the token(s) to delete',
            type: 'bytes',
            hint: 'token_category',
        },
        burnedTokenAmount: {
            name: 'Deleted Token Amount',
            description: 'The fungible token amount to delete',
            type: 'integer',
            hint: 'token_amount',
        },
        burnedTokenCapability: {
            name: 'Deleted Token Capability',
            description: 'The token capability for the non-fungible token to delete',
            type: 'bytes',
            hint: 'token_capability',
        },
        burnedTokenCommitment: {
            name: 'Deleted Token Commitment',
            description: 'The token commitment for the non-fungible token to delete',
            type: 'bytes',
            hint: 'token_commitment',
        },
    },

    // Define a list of re-usable icons that can be used as part of metadata.
    // NOTE: the actual icons are not embedded in the template but only referenced by hashes here,
    //       and can be distributed either as an asset pack or looked up through something like IPFS.
    icons: [
        {
            name: 'wallet',
            hash: '0000000000000000000000',
        },
        {
            name: 'owner',
            hash: '0000000000000000000000',
        },
        {
            name: 'sender',
            hash: '0000000000000000000000',
        },
        {
            name: 'address',
            hash: '0000000000000000000000',
        },
        {
            name: 'receive',
            hash: '0000000000000000000000',
        },
        {
            name: 'request',
            hash: '0000000000000000000000',
        },
        {
            name: 'send',
            hash: '0000000000000000000000',
        },
        {
            name: 'burn',
            hash: '0000000000000000000000',
        },
        {
            name: 'sign',
            hash: '0000000000000000000000',
        },
        {
            name: 'verify',
            hash: '0000000000000000000000',
        },
    ],

    scenarios: [
        {
            name: 'requesting satoshis',
            description: 'happy-path evaluation for requesting satoshis.',

            // The action being run in the scenario.
            action: 'requestSatoshis',

            // List of roles taken in this scenario, and the resources they provided.
            roles: [
                {
                    role: 'receiver',
                    values: {
                        generated: {
                            ownerKey: 'KyRQa5pEXuzVcDwnXRLpYAascjchQW5DoxVRMbj4DTxS83573mz8',
                        },
                        variables: {
                            requestedSatoshis: 2000,
                        },
                        secrets: {
                            // This scenario does not carry any secrets.
                        },
                        inputs: [],
                        outputs: [
                            {
                                lockingBytecode: '76a91475c715ecb74178fe87933e57e947e5e92d904b8188ac',
                                valueSatoshis: 2000,
                            },
                        ],
                    },
                },
                {
                    role: 'sender',
                    values: {
                        // The sender provides no raw data to the action.
                        generated: {},
                        variables: {},
                        secrets: {},

                        // The sender does provide input and change.
                        inputs: [
                            {
                                outpointTransactionHash: '4ef28553a31a266719e66ba97fee3aeecd6d1788f7ff6ab12f8ebceda49660c0',
                                outpointIndex: 0,
                                sequenceNumber: 0,
                                unlockingBytecode:
                                    '41226b2be7c2890c8bbde2f79e79640e56d866843f2e822ec51c469019d13db04a422c9ee49f5eefd26fee24e91910edbbb032b90cc54c34da80a61e69b0ee3d22412103e7ab26c36a7c7f45b2c26f33c08b0fa43a633268700f47216646d4cb37ae5696',
                            },
                        ],
                        outputs: [
                            {
                                lockingBytecode: '76a91475c715ecb74178fe87933e57e947e5e92d904b8188ac',
                                valueSatoshis: 2000,
                            },
                        ],
                    },
                },
            ],

            // List of resources provided outside the context of a role.
            values: {
                generated: {
                    // This scenario does not have any non-role generated values.
                },
                variables: {
                    // This scenario does not have any non-role variables.
                },
                secrets: {
                    // This scenario does not have any non-role secrets.
                },
            },

            // Outcomes provides the set of resulting values created from the action.
            outcome: {
                roles: {
                    receiver: {
                        name: 'Request',
                        description: 'Requested a specific amount of satoshis from one or more senders.',
                        icon: 'request',
                    },
                    sender: {
                        name: 'Send',
                        description: 'Sent a specific amount of satoshis to the provided receiver.',
                        icon: 'send',
                    },
                },

                transactions: [
                    {
                        transaction:
                            '0200000001c06096a4edbc8e2fb16afff788176dcdee3aee7fa96be61967261aa35385f24e000000006441226b2be7c2890c8bbde2f79e79640e56d866843f2e822ec51c469019d13db04a422c9ee49f5eefd26fee24e91910edbbb032b90cc54c34da80a61e69b0ee3d22412103e7ab26c36a7c7f45b2c26f33c08b0fa43a633268700f47216646d4cb37ae5696000000000267530300000000001976a91475c715ecb74178fe87933e57e947e5e92d904b8188acd0070000000000001976a91475c715ecb74178fe87933e57e947e5e92d904b8188ac00000000',
                        value: '',
                    },
                ],
            },
        },
    ],
};

export const p2pkhTemplateIdentifier = generateTemplateIdentifier(p2pkhTemplate);