Solana RPC connection
Anchor program instance for the Recurring Payments contract
Public key of the deployed program
Anchor provider with wallet and connection
Build the ordered remaining_accounts list for executePayment /
transfer referral reward distribution.
Returns null if the user has no ReferralAccount at all (caller should
invoke the instruction without any remaining accounts). Otherwise
returns a non-empty array whose first entry is the payer's own
ReferralAccount (read-only), followed by the writable ancestor chain
and their matching ATAs.
Layout (matches parse_and_validate_referral_accounts on-chain):
[payer_referral,
L1, L2, L3,
ATA_L1, ATA_L2, ATA_L3]
Composable gross approval sizing — wraps the face-only
calculatePolicyApprovalAmount in requiredDelegatedAmount
so the delegate covers fees across the policy's whole life (ADR-0026:
composable is NET-on-pull, every execution pulls face + fee, and the
SPL delegated_amount is a total cap decremented per pull).
Cap policy for unbounded variants (subscription with maxRenewals: null,
PayAsYouGo): deliberately matches the payment-policy helpers — 1 year.
One mental model across both policy families; the approval is re-issued on
every create/approve and trivially topped up, so 1yr parity is sufficient.
2yr was considered and rejected as YAGNI; if composables in practice need
longer, callers pass an explicit approvalAmount (or the helper's
year-multiplier changes in one place).
The policy configuration (any of the 5 variants)
The gateway account (carries gatewayFeeBps), or null
if not fetched/unknown — degrades to face-only (0 bps).
Gross approval amount (face_total + total_fee), face-only when
the gateway is unknown.
Changes the status of a composable policy (active, paused, or completed). Only the policy owner can change the status.
Public key of the token mint
ID of the composable policy to modify
New status for the policy
Transaction instruction to change the composable policy status
Changes the gateway fee in basis points for a payment gateway. Only the gateway authority can change the fee.
Public key of the gateway authority
New gateway fee in basis points (0-10000)
Transaction instruction to change the gateway fee bps
Changes the fee recipient for a payment gateway. Only the gateway authority can change the fee recipient.
Public key of the gateway authority
Public key of the new fee recipient
Transaction instruction to change the gateway fee recipient
Changes the signer authorized to execute payments for a gateway. Only the gateway authority can change the signer.
Public key of the current gateway authority
Public key of the new signer
Transaction instruction to change the gateway signer
Changes the status of a payment policy. Only Active <-> Paused is allowed
for owner-initiated transitions; completed is a program-internal
terminal state (subscription max_renewals reached, or all milestones
released) and is rejected on-chain with InvalidPolicyStatusTransition.
Only the policy owner can change the status.
The param type accepts the full PolicyStatus (including
completed) for parity with changeComposablePolicyStatus; callers
passing { active: {} } / { paused: {} } are unaffected.
Public key of the token mint
ID of the policy to modify
New status for the policy (completed rejected on-chain)
Transaction instruction to change the policy status
Rotates the protocol admin (ADR-0028). The current admin must sign.
fee_recipient is left untouched; the new admin can rotate it via the
existing admin-gated paths afterwards.
Public key of the new protocol admin
Transaction instruction to change the program authority
Creates a composable payment policy with full setup: owner input-mint ATA
ensure, UserPayment ensure, the policy instruction, and delegate
approve wiring. Mirrors createSubscription() for the composable
family, with two carve-outs — composable has no referrals, and execute
cannot be auto-called at create time (it needs caller-supplied forward
instructionData + remainingAccounts).
Use getCreateComposablePolicyInstruction() for just the policy ix.
Public key of the input token
Public key receiving the payment
Public key of the payment gateway
Policy configuration (subscription/milestone/payAsYouGo/oneTime/upTo)
Memo string (max 32 bytes)
Token forwarding configuration (output_mint sentinel = act mode)
Pre-validation spec (disabled by default)
Owner-pinned Lighthouse targets for pre-validation
Pre-validation assertion data
Post-validation spec (disabled by default)
Owner-pinned Lighthouse targets for post-validation
Post-validation assertion data
OptionalfeePayer: PublicKeyOptional fee payer (defaults to provider wallet)
OptionalapprovalAmount: BNOptional explicit approval (defaults to face-only sizing)
Ordered transaction instructions: [ownerATA?, userPayment?, policy, approve?]
OptionalfeePayer: PublicKeyOptionalapprovalAmount: BNCreates a milestone payment policy with full setup including ATAs, user payment account, and token approvals. Use getCreateMilestonePolicyInstruction() for just the instruction without setup.
Public key of the token mint
Public key of the payment recipient
Public key of the payment gateway
Array of amounts for each milestone (up to 4)
Array of timestamps when each milestone is due
Bitmap: bit0=check due date, bit1=gateway signer, bit2=owner signer, bit3=recipient signer. Bits 1-3 mutually exclusive.
Memo bytes for the payment policy
OptionalapprovalAmount: BNOptional specific approval amount (calculated automatically if not provided)
OptionalexecuteImmediately: booleanWhether to execute the first milestone immediately if due
OptionalreferralCode: stringOptionalfeePayer: PublicKeyArray of transaction instructions for complete setup
Creates a complete one-time payment setup including ATAs, user payment
account, policy, and token approvals. One-time policies fire exactly
once then transition to Completed. See ADR-0019.
Use getCreateOneTimePolicyInstruction() for just the instruction without setup.
Public key of the token mint
Public key of the payment recipient
Public key of the payment gateway
Fixed amount to pay (in smallest token units), must be > 0
Memo bytes for the payment policy
OptionaldueDate: BN | nullEarliest execution timestamp; null/omitted means immediate
OptionalexpiryDate: BN | nullHard deadline after which execution is rejected; null = never expires
OptionalapprovalAmount: BNOptional specific approval amount (defaults to amount)
OptionalreferralCode: stringOptional 6-character referral code
OptionalfeePayer: PublicKeyOptional explicit fee payer
Array of transaction instructions for the complete setup
Creates a pay-as-you-go payment policy with full setup including ATAs, user payment account, and token approvals. Use getCreatePayAsYouGoPolicyInstruction() for just the instruction without setup.
Public key of the token mint
Public key of the payment recipient
Public key of the payment gateway
Maximum amount allowed per period
Maximum amount that can be claimed in one go
Length of each period in seconds
Memo bytes for the payment policy
OptionalapprovalAmount: BNOptional specific approval amount (calculated automatically if not provided)
OptionalreferralCode: stringOptional referral code
OptionalexpiryDate: BN | nullOptional hard deadline (unix seconds); null/omitted = never expires (ADR-0024)
OptionalfeePayer: PublicKeyArray of transaction instructions for complete setup
OptionalapprovalAmount: BNOptionalreferralCode: stringOptionalexpiryDate: BN | nullOptionalfeePayer: PublicKeyCreates a new payment gateway for processing recurring payments. Gateways can charge fees and execute payments on behalf of users.
Public key that controls the gateway
Total fee in basis points (100 bps = 1%) charged by the gateway, decomposed into protocol/scheduler/referral/residual shares (ADR-0017).
Share of the gateway fee routed to the scheduler (execute-tx signer). Constraint: protocol_share + scheduler_share + referral_allocation ≤ 10000 bps.
Public key that receives gateway fees
Display name for the gateway (max 32 characters)
Website URL for the gateway (max 64 characters)
Transaction instruction to create the payment gateway
Creates a referral account for the current user within a specific gateway. The referral account stores the user's referral code and tracks their referrer (who referred them).
Public key of the gateway this referral account belongs to
6-character alphanumeric referral code for this user
Optionalreferrer: PublicKeyOptional public key of the user who referred this user (L1 referrer)
OptionalfeePayer: PublicKeyTransaction instruction to create the referral account
Creates a complete subscription setup including ATAs, user payment account, policy, and token approvals. This is the high-level method for creating subscriptions that handles all the setup automatically.
Public key of the token to be paid
Public key that receives the payments
Public key of the gateway that will execute payments
Amount to pay per interval (in smallest token units)
Whether the subscription should auto-renew
Maximum number of renewals allowed (null for unlimited)
How often payments should occur
Memo bytes to include with payments (max 64 bytes)
OptionalstartTime: BN | nullWhen the first payment should occur (defaults to now)
OptionalapprovalAmount: BNAmount to approve for token delegation (calculated automatically if not provided)
OptionalexecuteImmediately: booleanWhether to execute the first payment immediately
OptionalreferralCode: stringOptional 6-character referral code to associate with this subscription
OptionalfeePayer: PublicKeyArray of transaction instructions for the complete subscription setup
OptionalstartTime: BN | nullOptionalapprovalAmount: BNOptionalexecuteImmediately: booleanOptionalreferralCode: stringOptionalfeePayer: PublicKeyCreates a complete upto authorization setup including ATAs, user payment
account, policy, and token approvals. The authorization lets the resource
server / facilitator settle up to maxAmount once, within
[validAfter, deadline]. See ADR-0020.
Use getCreateUpToPolicyInstruction() for just the instruction without setup.
Public key of the token mint
Public key of the payment recipient
Public key of the payment gateway
Ceiling on the settlement amount (smallest token units)
Hard expiry timestamp; MUST be > 0
Memo bytes for the payment policy
OptionalvalidAfter: BN | nullEarliest settlement timestamp; omitted/null means immediate
OptionalapprovalAmount: BNOptional specific approval amount (defaults to maxAmount)
OptionalreferralCode: stringOptional 6-character referral code
OptionalfeePayer: PublicKeyOptional explicit fee payer
Array of transaction instructions for the complete setup
Creates a user payment account for tracking payments in a specific token. Each user needs one account per token mint they want to use for payments.
Public key of the token mint for payments
OptionalfeePayer: PublicKeyTransaction instruction to create the user payment account
Deletes a composable policy permanently. Only the policy owner can delete their composable policies.
Public key of the token mint
ID of the composable policy to delete
Transaction instruction to delete the composable policy
Deletes a payment gateway. Only the protocol admin can delete gateways.
Public key of the gateway authority
Transaction instruction to delete the payment gateway
Deletes a payment policy permanently. Only the policy owner can delete their policies.
Public key of the token mint
ID of the policy to delete
Transaction instruction to delete the payment policy
Deletes a user payment account, closing it and refunding rent to the owner. Only the owner can delete their own user payment account, and only when it has no active policies or composables. Blocked while the program is paused.
Public key of the token mint
Transaction instruction to delete the user payment account
Disables a specific feature flag on a gateway.
Public key of the gateway authority
One of GATEWAY_FEATURES values
Transaction instruction
Enables a specific feature flag on a gateway.
Public key of the gateway authority
One of GATEWAY_FEATURES values
Transaction instruction
Builds the full instruction bundle to execute a composable payment,
prepending create-ATA ensures for the recipient and the two fee
recipients (all input-side per ADR-0026). Mirrors executePayment().
The two intermediate ATAs are owned + created on-chain by the program (create_ata guards on zero lamports) — they are NEVER ensured here.
Public key of the composable policy account
Buffer containing the forward instruction data
OptionalforwardAmount: BN | nullOptional amount to forward (null if no forward)
OptionalremainingAccounts: AccountMeta[]Additional accounts for validation/forward
Ordered instructions: [recipientATA?, gatewayFeeATA?, protocolFeeATA?, execute]
Executes a payment for a given payment policy. This method handles the complete payment execution flow including fee calculations and token transfers.
Public key of the payment policy account
OptionalpaymentAmount: BNAmount to pay (optional for subscription/milestone, required for pay-as-you-go)
Optionalrecipient: PublicKeyPublic key of the payment recipient (optional if in policy)
OptionaltokenMint: PublicKeyPublic key of the token mint (optional if in policy)
Optionalgateway: PublicKeyPublic key of the payment gateway (optional if in policy)
Optionaluser: PublicKeyPublic key of the payment user (optional if in policy)
Array of transaction instructions including ATA creation and payment execution
Retrieves all composable policies.
Array of all composable policies
Retrieves all payment gateways in the protocol.
Array of payment gateway accounts with their public keys
Retrieves all payment policies in the protocol.
Array of payment policy accounts with their public keys
Retrieves all user payment accounts in the protocol.
Array of user payment accounts with their public keys
Retrieves all user payment accounts owned by a specific user.
Public key of the user
Array of user payment accounts owned by the specified user
Retrieve ComposablePolicy accounts with a combined memcmp filter set.
Optionalfilters: {userPayment, gateway, recipient, trackingId
Retrieves all composable policies executed by the specified gateway.
Public key of the payment gateway
Array of composable policies executed by the gateway
Retrieves all composable policies belonging to the specified user payment account.
Public key of the user payment PDA
Array of composable policies for the user payment account
Fetches a specific composable policy account by its address.
Public key of the composable policy account
The composable policy account data or null if not found
Gets a Composable Policy PDA for the specified user payment and policy ID.
Public key of the user's payment PDA
Unique identifier for the composable policy
PdaResult containing the PDA address and bump
Gets a transaction instruction to create a composable payment policy. Composable policies allow execution of arbitrary instructions alongside optional token forwards, enabling use cases like automated DCA, liquidation protection, and cross-protocol interactions.
The validation target accounts are owner-pinned at creation
(ADR-0016, closes validation-gaming vector d): pinnedAccounts is
stored in the on-chain ValidationPda and replay-validated at
execute — a relayer cannot substitute a positional slot to trip the
assertion against the wrong state. Pass exactly the Lighthouse
builder's .accounts pubkeys here (arity derived from the array
length; max 2).
Public key of the token to be paid
Public key that receives the payments
Public key of the gateway that will execute payments
Policy configuration defining execution timing
Memo string to include with the policy (max 32 bytes)
Token forwarding configuration. In act mode
(ADR-0026) set outputMint to PublicKey.default (sentinel) and
the program treats the forward as consuming input without producing
a fungible output token (e.g. Velocity subaccount deposit). In
deliver modes, outputMint is a real SPL Mint (== inputMint for
deliver-no-transform, distinct for deliver-transform).
OptionalfeePayer: PublicKeyOptional fee payer (defaults to provider wallet)
Transaction instruction to create the composable policy
Gets a transaction instruction to create a milestone payment policy. This is a low-level method that returns only the instruction. Use createMilestonePayment() for the full setup including ATAs and approvals.
Public key of the token to be paid
Public key that receives the payments
Public key of the gateway that will execute payments
Array of amounts for each milestone (up to 4)
Array of timestamps when each milestone is due
Bitmap: bit0=check due date, bit1=gateway signer, bit2=owner signer, bit3=recipient signer. Bits 1-3 mutually exclusive.
Memo bytes to include with payments (max 64 bytes)
OptionalfeePayer: PublicKeyTransaction instruction to create the milestone payment policy
Gets a transaction instruction to create a one-time payment policy. This is a low-level method that returns only the instruction. Use createOneTimePayment() for the full setup including ATAs and approvals.
One-time policies fire exactly once, then transition to Completed. They
flow through the full gateway machinery (fees, referrals, composable
hooks) — see ADR-0019.
Public key of the token to be paid
Public key that receives the payment
Public key of the gateway that will execute the payment
Fixed amount to pay (in smallest token units), must be > 0
Earliest execution timestamp; null/<= 0 means immediate
Hard deadline after which execution is rejected; null = never expires
Memo bytes to include with payments (max 64 bytes)
OptionalfeePayer: PublicKeyOptional explicit fee payer (defaults to the provider wallet)
Transaction instruction to create the one-time payment policy
Gets a transaction instruction to create a pay-as-you-go payment policy. This is a low-level method that returns only the instruction. Use createPayAsYouGoPayment() for the full setup including ATAs and approvals.
Public key of the token to be paid
Public key that receives the payments
Public key of the gateway that will execute payments
Maximum amount allowed per period
Maximum amount that can be claimed in a single payment
Length of each period in seconds
Memo bytes to include with payments (max 64 bytes)
OptionalexpiryDate: BN | nullOptional hard deadline (unix seconds); when current_time > expiryDate execution is rejected. null/omitted = never expires (ADR-0024).
OptionalfeePayer: PublicKeyTransaction instruction to create the pay-as-you-go payment policy
Gets a transaction instruction to create a subscription payment policy. This is a low-level method that returns only the instruction. Use createSubscription() for the full setup including ATAs and approvals.
Public key of the token to be paid
Public key that receives the payments
Public key of the gateway that will execute payments
Amount to pay per interval (in smallest token units)
Whether the subscription should auto-renew
Maximum number of renewals allowed (null for unlimited)
How often payments should occur
Memo bytes to include with payments (max 64 bytes)
OptionalstartTime: BN | nullWhen the first payment should occur (defaults to now)
OptionalfeePayer: PublicKeyTransaction instruction to create the subscription payment policy
Gets a transaction instruction to create an upto authorization policy.
Single-use, time-bound: the actual settled amount is caller-supplied at
execute time, bounded by maxAmount. See ADR-0020.
Use createUpToAuthorization() for the full setup including ATAs and approvals.
Public key of the token to be paid
Public key that receives the payment
Public key of the gateway that will execute the payment
Ceiling on the settlement amount (smallest token units), must be > 0
Earliest settlement timestamp; null/<= 0 means immediate
Hard expiry (strict < at execute time); MUST be > 0 and > validAfter
Memo bytes to include with payments (max 64 bytes)
OptionalfeePayer: PublicKeyOptional explicit fee payer (defaults to the provider wallet)
Transaction instruction to create the upto policy
Gets a Payment Gateway PDA for the specified authority.
Public key of the gateway authority
PdaResult containing the PDA address and bump
Fetches a specific payment gateway account by its address.
Public key of the payment gateway account
The payment gateway account data or null if not found
Retrieves all payment gateways where the specified key is the authorized signer. Unlike the authority (which is unique per gateway PDA), a single signer key can manage multiple gateways — this returns all of them.
Public key of the gateway signer
Array of payment gateway accounts with their public keys
Retrieve PaymentPolicy accounts with a combined memcmp filter set.
Every field is optional; omitting all returns every PaymentPolicy (subject to RPC limits).
Optionalfilters: {userPayment, gateway, recipient, trackingId
Retrieves all payment policies executed by the specified gateway.
Public key of the payment gateway
Array of payment policies executed by the gateway
Retrieves all payment policies belonging to the specified user payment account.
Array of payment policies for the user payment account
Retrieves all payment policies where the specified user is the recipient.
Public key of the payment recipient
Array of payment policies where the user is the recipient
Retrieves all payment policies where the specified user is the payer.
Public key of the payment user
Array of payment policies where the user is the payer
Retrieves all payment policies belonging to the specified user payment account.
Public key of the user payment PDA
Array of payment policies for the user payment account
Fetches a specific payment policy account by its address.
Public key of the payment policy account
The payment policy account data or null if not found
Gets a Payment Policy PDA for the specified user payment and policy ID.
Public key of the user's payment PDA
Unique identifier for the policy within the user's account
PdaResult containing the PDA address and bump
Gets the Payments Delegate PDA used for token delegation (legacy).
PdaResult containing the PDA address and bump
Fetches the program configuration account.
Public key of the program config account
The program configuration data or null if not found
Fetches a specific referral account by its address.
Public key of the referral account
The referral account data or null if not found
Same as getReferralAccountByOwner but also returns the on-chain
address of the ReferralAccount PDA. Required by C-02 remediation so the
caller can pass the payer's ReferralAccount as the first entry in
remaining_accounts for executePayment / transfer.
Fetches a referral account by gateway and referral code.
Public key of the gateway
6-character alphanumeric referral code
The referral account data or null if not found
Fetches a specific referral account by the owner's public key and gateway. This is a convenience method that finds the referral account for an owner within a specific gateway.
Public key of the gateway
Public key of the referral account owner
The referral account data or null if not found
Builds the referral chain for a given user and gateway. This method traverses the referral chain up to 3 levels deep. We replace the default PublicKey by null here!
C-02 remediation: the caller MUST also pass the payer's own
ReferralAccount to executePayment / transfer as the FIRST entry in
remaining_accounts. Use getReferralAccountAddressByOwner to
obtain it, or use buildReferralRemainingAccounts which returns
the full ordered list ready for remainingAccounts(...).
Public key of the user to find the referral chain for
Public key of the gateway
Array of referral account addresses [L1, L2, L3] (may contain nulls)
Gets a Referral Account PDA for the specified gateway and referral code.
Public key of the gateway
6-byte buffer of the referral code
PdaResult containing the PDA address and bump
Fetches a specific user payment account by its address.
Public key of the user payment account
The user payment account data or null if not found
Gets a User Payment PDA for the specified user and token mint.
Public key of the user
Public key of the token mint
PdaResult containing the PDA address and bump
Initializes the Tributary protocol by creating the program configuration account. This is a one-time setup that must be performed by the protocol admin.
Public key of the protocol administrator
Transaction instruction to initialize the protocol
Migrates token delegation from the legacy global payments_delegate PDA to the per-user UserPayment PDA. Approves the new one with the specified amount.
Public key of the token mint
Amount to approve for the new delegate
Array of [approve] transaction instructions
Compute the gross amount a composable policy will pull from the user's token account for a given face amount and gateway (ADR-0026).
Composable fees are NET-on-pull (hardcoded): the pull moves
face + fee. The delegate approval on the user's token account must
cover this gross amount, and the user's balance must be ≥ gross.
Use this to size the approve instruction issued alongside
createComposablePolicy / createUserPayment, and to re-check after a
gateway fee-bps change (a hike can fail execution at the delegate).
The policy face amount (what the forward consumes / what the recipient is owed before fees). For PayAsYouGo this is the chunk.
The gateway account (carries gatewayFeeBps).
OptionalprotocolShareBps: numberThe global protocol share from ProgramConfig,
unless the gateway has FEATURE_CUSTOM_PROTOCOL_FEE set.
The gross pull amount (face + total_fee).
Toggles the emergency pause kill-switch (AUDIT-2026-07-09 L-01). When paused, all execute_payment / execute_composable / transfer calls fail. Only the protocol admin can call this.
true to pause, false to resume
Transaction instruction to set the emergency pause flag
Settle an upto authorization with the actual amount (determined by the
resource server after usage). Thin wrapper over executePayment that
pins the caller-supplied amount — on-chain enforces 0 <= actual <= max
and the [validAfter, deadline) window. See ADR-0020.
Public key of the upto payment policy
Actual settle amount (smallest token units); MAY be 0
Optionalrecipient: PublicKeyPublic key of the payment recipient (optional if in policy)
OptionaltokenMint: PublicKeyPublic key of the token mint (optional if in policy)
Optionalgateway: PublicKeyPublic key of the payment gateway (optional if in policy)
Optionaluser: PublicKeyPublic key of the payment user (optional if in policy)
Array of transaction instructions including ATA creation and settlement
Executes a one-time token transfer with protocol and gateway fee distribution. The amount parameter is the GROSS amount - the total that leaves the user's wallet. Fees are deducted from this amount: recipient gets (amount - gateway_fee - protocol_fee).
Public key of the token mint
Public key of the payment recipient
Public key of the payment gateway account (PDA)
GROSS amount to transfer (total leaving user's wallet, fees included)
Memo string or 64-byte array to include with the payment
OptionalreferralCode: stringOptional 6-character referral code for referral rewards
Array of transaction instructions (ATA creation + transfer)
Sets the raw feature_flags byte on a gateway (authority-only). Bit 2 (CUSTOM_PROTOCOL_FEE) is protected and cannot be changed here — use updateGatewayCustomProtocolFee for that.
Public key of the gateway authority
Raw feature flags byte (only bits 0-1 are applied)
Transaction instruction
Updates the custom protocol share settings for a payment gateway (ADR-0017). Only the protocol admin can modify these settings. This allows setting a gateway-specific protocol share that overrides the global default.
Public key of the gateway authority
Whether to use custom protocol share (true) or global default (false)
Custom protocol share in basis points (0-10000). Only used if useCustomProtocolFee is true.
Transaction instruction to update gateway protocol share settings
Updates the referral settings for a payment gateway. Only the gateway authority can update these settings.
Public key of the gateway authority
Bit flags to enable/disable features (bit 0 = referral enabled)
Basis points of gateway fee allocated to referral rewards (0-2500)
Array of 3 values [L1, L2, L3] summing to 10000 bps
Transaction instruction to update gateway referral settings
Updates the scheduler share of the gateway fee (ADR-0017). Gateway-authority-only. The scheduler share pays the execute-tx signer; when the gateway signer self-executes it merges into fee_recipient. Constraint: protocol_share + scheduler_share + referral_allocation ≤ 10000 bps, validated on-chain against the current ProgramConfig.
Public key of the gateway authority (must sign)
Share of the gateway fee routed to the scheduler (0-10000)
Transaction instruction to update gateway scheduler share
Updates the wallet used by the SDK instance. Useful for changing the signer without creating a new SDK instance.
New wallet to use for signing transactions
Validates a referral code format. Referral codes must be exactly 6 alphanumeric characters.
The referral code to validate
true if valid, false otherwise
Main SDK class for interacting with the Tributary recurring payments protocol on Solana. Provides methods to create payment gateways, user accounts, payment policies, and execute payments.
Example