Class Tributary

constructor

• new Tributary(connection: Connection, wallet: Wallet): Tributary

  Creates a new Tributary SDK instance.

  Parameters

  • connection: Connection

    Solana RPC connection to use for all operations

  • wallet: Wallet

    Wallet containing the keypair for signing transactions

  Returns Tributary

connection

program

programId

provider

changeGatewayFeeBps

• changeGatewayFeeBps(
      gatewayAuthority: PublicKey,
      newFeeBps: number,
  ): Promise<TransactionInstruction>

  Changes the gateway fee in basis points for a payment gateway. Only the gateway authority can change the fee.

  Parameters

  • gatewayAuthority: PublicKey

    Public key of the gateway authority

  • newFeeBps: number

    New gateway fee in basis points (0-10000)

  Returns Promise<TransactionInstruction>

  Transaction instruction to change the gateway fee bps

changeGatewayFeeRecipient

• changeGatewayFeeRecipient(
      gatewayAuthority: PublicKey,
      newFeeRecipient: PublicKey,
  ): Promise<TransactionInstruction>

  Changes the fee recipient for a payment gateway. Only the gateway authority can change the fee recipient.

  Parameters

  • gatewayAuthority: PublicKey

    Public key of the gateway authority

  • newFeeRecipient: PublicKey

    Public key of the new fee recipient

  Returns Promise<TransactionInstruction>

  Transaction instruction to change the gateway fee recipient

changeGatewaySigner

• changeGatewaySigner(
      gatewayAuthority: PublicKey,
      newSigner: PublicKey,
  ): Promise<TransactionInstruction>

  Changes the signer authorized to execute payments for a gateway. Only the gateway authority can change the signer.

  Parameters

  • gatewayAuthority: PublicKey

    Public key of the current gateway authority

  • newSigner: PublicKey

    Public key of the new signer

  Returns Promise<TransactionInstruction>

  Transaction instruction to change the gateway signer

changePaymentPolicyStatus

• changePaymentPolicyStatus(
      tokenMint: PublicKey,
      policyId: number,
      newStatus: { active: {} } | { paused: {} },
  ): Promise<TransactionInstruction>

  Changes the status of a payment policy (active or paused). Only the policy owner can change the status.

  Parameters

  • tokenMint: PublicKey

    Public key of the token mint

  • policyId: number

    ID of the policy to modify

  • newStatus: { active: {} } | { paused: {} }

    New status for the policy

  Returns Promise<TransactionInstruction>

  Transaction instruction to change the policy status

confirmTransactionWithStatus

• confirmTransactionWithStatus(
      signature: string,
      commitment?: "processed" | "confirmed" | "finalized",
      interval?: number,
      timeout?: number,
  ): Promise<SignatureStatus>

  Parameters

  • signature: string
  • commitment: "processed" | "confirmed" | "finalized" = "confirmed"
  • interval: number = 150
  • timeout: number = 60000

  Returns Promise<SignatureStatus>

createMilestone

• createMilestone(
      tokenMint: PublicKey,
      recipient: PublicKey,
      gateway: PublicKey,
      milestoneAmounts: BN[],
      milestoneTimestamps: BN[],
      releaseCondition: number,
      memo: number[],
      approvalAmount?: BN,
      executeImmediately?: boolean,
      referralCode?: string,
  ): Promise<TransactionInstruction[]>

  Creates a milestone payment policy with full setup including ATAs, user payment account, and token approvals. Use getCreateMilestonePolicyInstruction() for just the instruction without setup.

  Parameters

  • tokenMint: PublicKey

    Public key of the token mint

  • recipient: PublicKey

    Public key of the payment recipient

  • gateway: PublicKey

    Public key of the payment gateway

  • milestoneAmounts: BN[]

    Array of amounts for each milestone (up to 4)

  • milestoneTimestamps: BN[]

    Array of timestamps when each milestone is due

  • releaseCondition: number

    Bitmap: bit0=check due date, bit1=gateway signer, bit2=owner signer, bit3=recipient signer. Bits 1-3 mutually exclusive.

  • memo: number[]

    Memo bytes for the payment policy

  • OptionalapprovalAmount: BN

    Optional specific approval amount (calculated automatically if not provided)

  • OptionalexecuteImmediately: boolean

    Whether to execute the first milestone immediately if due

  • OptionalreferralCode: string

  Returns Promise<TransactionInstruction[]>

  Array of transaction instructions for complete setup

createPayAsYouGo

• createPayAsYouGo(
      tokenMint: PublicKey,
      recipient: PublicKey,
      gateway: PublicKey,
      maxAmountPerPeriod: BN,
      maxChunkAmount: BN,
      periodLengthSeconds: BN,
      memo: number[],
      approvalAmount?: BN,
      referralCode?: string,
  ): Promise<TransactionInstruction[]>

  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.

  Parameters

  • tokenMint: PublicKey

    Public key of the token mint

  • recipient: PublicKey

    Public key of the payment recipient

  • gateway: PublicKey

    Public key of the payment gateway

  • maxAmountPerPeriod: BN

    Maximum amount allowed per period

  • maxChunkAmount: BN

    Maximum amount that can be claimed in one go

  • periodLengthSeconds: BN

    Length of each period in seconds

  • memo: number[]

    Memo bytes for the payment policy

  • OptionalapprovalAmount: BN

    Optional specific approval amount (calculated automatically if not provided)

  • OptionalreferralCode: string

  Returns Promise<TransactionInstruction[]>

  Array of transaction instructions for complete setup

createPaymentGateway

• createPaymentGateway(
      authority: PublicKey,
      gatewayFeeBps: number,
      gatewayFeeRecipient: PublicKey,
      name: string,
      url: string,
  ): Promise<TransactionInstruction>

  Creates a new payment gateway for processing recurring payments. Gateways can charge fees and execute payments on behalf of users.

  Parameters

  • authority: PublicKey

    Public key that controls the gateway

  • gatewayFeeBps: number

    Fee in basis points (100 bps = 1%) charged by the gateway

  • gatewayFeeRecipient: PublicKey

    Public key that receives gateway fees

  • name: string

    Display name for the gateway (max 32 characters)

  • url: string

    Website URL for the gateway (max 64 characters)

  Returns Promise<TransactionInstruction>

  Transaction instruction to create the payment gateway

createReferralAccount

• createReferralAccount(
      gateway: PublicKey,
      referralCode: string,
      referrer?: PublicKey,
  ): Promise<TransactionInstruction>

  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).

  Parameters

  • gateway: PublicKey

    Public key of the gateway this referral account belongs to

  • referralCode: string

    6-character alphanumeric referral code for this user

  • Optionalreferrer: PublicKey

    Optional public key of the user who referred this user (L1 referrer)

  Returns Promise<TransactionInstruction>

  Transaction instruction to create the referral account

createSubscription

• createSubscription(
      tokenMint: PublicKey,
      recipient: PublicKey,
      gateway: PublicKey,
      amount: BN,
      autoRenew: boolean,
      maxRenewals: number | null,
      paymentFrequency: DecodeEnum,
      memo: number[],
      startTime?: BN | null,
      approvalAmount?: BN,
      executeImmediately?: boolean,
      referralCode?: string,
  ): Promise<TransactionInstruction[]>

  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.

  Parameters

  • tokenMint: PublicKey

    Public key of the token to be paid

  • recipient: PublicKey

    Public key that receives the payments

  • gateway: PublicKey

    Public key of the gateway that will execute payments

  • amount: BN

    Amount to pay per interval (in smallest token units)

  • autoRenew: boolean

    Whether the subscription should auto-renew

  • maxRenewals: number | null

    Maximum number of renewals allowed (null for unlimited)

  • paymentFrequency: DecodeEnum

    How often payments should occur

  • memo: number[]

    Memo bytes to include with payments (max 64 bytes)

  • OptionalstartTime: BN | null

    When the first payment should occur (defaults to now)

  • OptionalapprovalAmount: BN

    Amount to approve for token delegation (calculated automatically if not provided)

  • OptionalexecuteImmediately: boolean

    Whether to execute the first payment immediately

  • OptionalreferralCode: string

    Optional 6-character referral code to associate with this subscription

  Returns Promise<TransactionInstruction[]>

  Array of transaction instructions for the complete subscription setup

createUserPayment

• createUserPayment(tokenMint: PublicKey): Promise<TransactionInstruction>

  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.

  Parameters

  • tokenMint: PublicKey

    Public key of the token mint for payments

  Returns Promise<TransactionInstruction>

  Transaction instruction to create the user payment account

deletePaymentGateway

• deletePaymentGateway(
      gatewayAuthority: PublicKey,
  ): Promise<TransactionInstruction>

  Deletes a payment gateway. Only the protocol admin can delete gateways.

  Parameters

  • gatewayAuthority: PublicKey

    Public key of the gateway authority

  Returns Promise<TransactionInstruction>

  Transaction instruction to delete the payment gateway

deletePaymentPolicy

• deletePaymentPolicy(
      tokenMint: PublicKey,
      policyId: number,
  ): Promise<TransactionInstruction>

  Deletes a payment policy permanently. Only the policy owner can delete their policies.

  Parameters

  • tokenMint: PublicKey

    Public key of the token mint

  • policyId: number

    ID of the policy to delete

  Returns Promise<TransactionInstruction>

  Transaction instruction to delete the payment policy

executePayment

• executePayment(
      paymentPolicyPda: PublicKey,
      paymentAmount?: BN,
      recipient?: PublicKey,
      tokenMint?: PublicKey,
      gateway?: PublicKey,
      user?: PublicKey,
  ): Promise<TransactionInstruction[]>

  Executes a payment for a given payment policy. This method handles the complete payment execution flow including fee calculations and token transfers.

  Parameters

  • paymentPolicyPda: PublicKey

    Public key of the payment policy account

  • OptionalpaymentAmount: BN

    Amount to pay (optional for subscription/milestone, required for pay-as-you-go)

  • Optionalrecipient: PublicKey

    Public key of the payment recipient (optional if in policy)

  • OptionaltokenMint: PublicKey

    Public key of the token mint (optional if in policy)

  • Optionalgateway: PublicKey

    Public key of the payment gateway (optional if in policy)

  • Optionaluser: PublicKey

    Public key of the payment user (optional if in policy)

  Returns Promise<TransactionInstruction[]>

  Array of transaction instructions including ATA creation and payment execution

getAllPaymentGateway

• getAllPaymentGateway(): Promise<
      {
          account: {
              authority: PublicKey;
              bump: number;
              createdAt: BN;
              customProtocolFeeBps: number;
              featureFlags: number;
              feeRecipient: PublicKey;
              gatewayFeeBps: number;
              isActive: boolean;
              name: number[];
              padding: number[];
              padding1: BN;
              referralAllocationBps: number;
              referralTiersBps: number[];
              signer: PublicKey;
              url: number[];
          };
          publicKey: PublicKey;
      }[],
  >

  Retrieves all payment gateways in the protocol.

  Returns Promise<
      {
          account: {
              authority: PublicKey;
              bump: number;
              createdAt: BN;
              customProtocolFeeBps: number;
              featureFlags: number;
              feeRecipient: PublicKey;
              gatewayFeeBps: number;
              isActive: boolean;
              name: number[];
              padding: number[];
              padding1: BN;
              referralAllocationBps: number;
              referralTiersBps: number[];
              signer: PublicKey;
              url: number[];
          };
          publicKey: PublicKey;
      }[],
  >

  Array of payment gateway accounts with their public keys

getAllPaymentPolicies

• getAllPaymentPolicies(): Promise<
      {
          account: {
              bump: number;
              createdAt: BN;
              gateway: PublicKey;
              memo: number[];
              padding: number[];
              paymentCount: number;
              policyId: number;
              policyType: DecodeEnum<
                  {
                      kind: "enum";
                      variants: [
                          {
                              fields: [
                                  { name: "amount"; type: "u64" },
                                  { name: "autoRenew"; type: "bool" },
                                  { name: "maxRenewals"; type: { option: ... } },
                                  { name: "paymentFrequency"; type: { defined: ... } },
                                  { name: "nextPaymentDue"; type: "i64" },
                                  { name: "padding"; type: { array: ... } },
                              ];
                              name: "subscription";
                          },
                          {
                              fields: [
                                  { name: "milestoneAmounts"; type: { array: ... } },
                                  { name: "milestoneTimestamps"; type: { array: ... } },
                                  { name: "currentMilestone"; type: "u8" },
                                  { name: "releaseCondition"; type: "u8" },
                                  { name: "totalMilestones"; type: "u8" },
                                  { name: "escrowAmount"; type: "u64" },
                                  { name: "padding"; type: { array: ... } },
                              ];
                              name: "milestone";
                          },
                          {
                              fields: [
                                  { name: "maxAmountPerPeriod"; type: "u64" },
                                  { name: "maxChunkAmount"; type: "u64" },
                                  { name: "periodLengthSeconds"; type: "u64" },
                                  { name: "currentPeriodStart"; type: "i64" },
                                  { name: "currentPeriodTotal"; type: "u64" },
                                  { name: "padding"; type: { array: ... } },
                              ];
                              name: "payAsYouGo";
                          },
                      ];
                  },
                  DecodedHelper<
                      [
                          {
                              docs: [
                                  "An event that is thrown when a gateway fee bps is changed",
                              ];
                              name: "gatewayFeeBpsChanged";
                              type: {
                                  fields: [
                                      { name: ...; type: ... },
                                      { name: ...; type: ... },
                                      { name: ...; type: ... },
                                  ];
                                  kind: "struct";
                              };
                          },
                          {
                              docs: [
                                  "An event that is thrown when a gateway fee recipient is changed",
                              ];
                              name: "gatewayFeeRecipientChanged";
                              type: {
                                  fields: [
                                      { name: ...; type: ... },
                                      { name: ...; type: ... },
                                      { name: ...; type: ... },
                                  ];
                                  kind: "struct";
                              };
                          },
                          {
                              docs: ["An event that is thrown when a gateway signer is changed"];
                              name: "gatewaySignerChanged";
                              type: {
                                  fields: [
                                      { name: ...; type: ... },
                                      { name: ...; type: ... },
                                      { name: ...; type: ... },
                                  ];
                                  kind: "struct";
                              };
                          },
                      ],
                      EmptyDefined,
                  >,
              >;
              recipient: PublicKey;
              status: DecodeEnum<
                  { kind: "enum"; variants: [{ name: "active" }, { name: "paused" }] },
                  DecodedHelper<
                      [
                          {
                              docs: [
                                  "An event that is thrown when a gateway fee bps is changed",
                              ];
                              name: "gatewayFeeBpsChanged";
                              type: {
                                  fields: [
                                      { name: ...; type: ... },
                                      { name: ...; type: ... },
                                      { name: ...; type: ... },
                                  ];
                                  kind: "struct";
                              };
                          },
                          {
                              docs: [
                                  "An event that is thrown when a gateway fee recipient is changed",
                              ];
                              name: "gatewayFeeRecipientChanged";
                              type: {
                                  fields: [
                                      { name: ...; type: ... },
                                      { name: ...; type: ... },
                                      { name: ...; type: ... },
                                  ];
                                  kind: "struct";
                              };
                          },
                          {
                              docs: ["An event that is thrown when a gateway signer is changed"];
                              name: "gatewaySignerChanged";
                              type: {
                                  fields: [
                                      { name: ...; type: ... },
                                      { name: ...; type: ... },
                                      { name: ...; type: ... },
                                  ];
                                  kind: "struct";
                              };
                          },
                      ],
                      EmptyDefined,
                  >,
              >;
              totalPaid: BN;
              updatedAt: BN;
              userPayment: PublicKey;
          };
          publicKey: PublicKey;
      }[],
  >

  Retrieves all payment policies in the protocol.

  Returns Promise<
      {
          account: {
              bump: number;
              createdAt: BN;
              gateway: PublicKey;
              memo: number[];
              padding: number[];
              paymentCount: number;
              policyId: number;
              policyType: DecodeEnum<
                  {
                      kind: "enum";
                      variants: [
                          {
                              fields: [
                                  { name: "amount"; type: "u64" },
                                  { name: "autoRenew"; type: "bool" },
                                  { name: "maxRenewals"; type: { option: ... } },
                                  { name: "paymentFrequency"; type: { defined: ... } },
                                  { name: "nextPaymentDue"; type: "i64" },
                                  { name: "padding"; type: { array: ... } },
                              ];
                              name: "subscription";
                          },
                          {
                              fields: [
                                  { name: "milestoneAmounts"; type: { array: ... } },
                                  { name: "milestoneTimestamps"; type: { array: ... } },
                                  { name: "currentMilestone"; type: "u8" },
                                  { name: "releaseCondition"; type: "u8" },
                                  { name: "totalMilestones"; type: "u8" },
                                  { name: "escrowAmount"; type: "u64" },
                                  { name: "padding"; type: { array: ... } },
                              ];
                              name: "milestone";
                          },
                          {
                              fields: [
                                  { name: "maxAmountPerPeriod"; type: "u64" },
                                  { name: "maxChunkAmount"; type: "u64" },
                                  { name: "periodLengthSeconds"; type: "u64" },
                                  { name: "currentPeriodStart"; type: "i64" },
                                  { name: "currentPeriodTotal"; type: "u64" },
                                  { name: "padding"; type: { array: ... } },
                              ];
                              name: "payAsYouGo";
                          },
                      ];
                  },
                  DecodedHelper<
                      [
                          {
                              docs: [
                                  "An event that is thrown when a gateway fee bps is changed",
                              ];
                              name: "gatewayFeeBpsChanged";
                              type: {
                                  fields: [
                                      { name: ...; type: ... },
                                      { name: ...; type: ... },
                                      { name: ...; type: ... },
                                  ];
                                  kind: "struct";
                              };
                          },
                          {
                              docs: [
                                  "An event that is thrown when a gateway fee recipient is changed",
                              ];
                              name: "gatewayFeeRecipientChanged";
                              type: {
                                  fields: [
                                      { name: ...; type: ... },
                                      { name: ...; type: ... },
                                      { name: ...; type: ... },
                                  ];
                                  kind: "struct";
                              };
                          },
                          {
                              docs: ["An event that is thrown when a gateway signer is changed"];
                              name: "gatewaySignerChanged";
                              type: {
                                  fields: [
                                      { name: ...; type: ... },
                                      { name: ...; type: ... },
                                      { name: ...; type: ... },
                                  ];
                                  kind: "struct";
                              };
                          },
                      ],
                      EmptyDefined,
                  >,
              >;
              recipient: PublicKey;
              status: DecodeEnum<
                  { kind: "enum"; variants: [{ name: "active" }, { name: "paused" }] },
                  DecodedHelper<
                      [
                          {
                              docs: [
                                  "An event that is thrown when a gateway fee bps is changed",
                              ];
                              name: "gatewayFeeBpsChanged";
                              type: {
                                  fields: [
                                      { name: ...; type: ... },
                                      { name: ...; type: ... },
                                      { name: ...; type: ... },
                                  ];
                                  kind: "struct";
                              };
                          },
                          {
                              docs: [
                                  "An event that is thrown when a gateway fee recipient is changed",
                              ];
                              name: "gatewayFeeRecipientChanged";
                              type: {
                                  fields: [
                                      { name: ...; type: ... },
                                      { name: ...; type: ... },
                                      { name: ...; type: ... },
                                  ];
                                  kind: "struct";
                              };
                          },
                          {
                              docs: ["An event that is thrown when a gateway signer is changed"];
                              name: "gatewaySignerChanged";
                              type: {
                                  fields: [
                                      { name: ...; type: ... },
                                      { name: ...; type: ... },
                                      { name: ...; type: ... },
                                  ];
                                  kind: "struct";
                              };
                          },
                      ],
                      EmptyDefined,
                  >,
              >;
              totalPaid: BN;
              updatedAt: BN;
              userPayment: PublicKey;
          };
          publicKey: PublicKey;
      }[],
  >

  Array of payment policy accounts with their public keys

getAllUserPayments

• getAllUserPayments(): Promise<
      {
          account: {
              activePoliciesCount: number;
              bump: number;
              createdAt: BN;
              createdPoliciesCount: number;
              isActive: boolean;
              owner: PublicKey;
              padding: number[];
              tokenAccount: PublicKey;
              tokenMint: PublicKey;
              updatedAt: BN;
          };
          publicKey: PublicKey;
      }[],
  >

  Retrieves all user payment accounts in the protocol.

  Returns Promise<
      {
          account: {
              activePoliciesCount: number;
              bump: number;
              createdAt: BN;
              createdPoliciesCount: number;
              isActive: boolean;
              owner: PublicKey;
              padding: number[];
              tokenAccount: PublicKey;
              tokenMint: PublicKey;
              updatedAt: BN;
          };
          publicKey: PublicKey;
      }[],
  >

  Array of user payment accounts with their public keys

getAllUserPaymentsByOwner

• getAllUserPaymentsByOwner(
      owner: PublicKey,
  ): Promise<
      {
          account: {
              activePoliciesCount: number;
              bump: number;
              createdAt: BN;
              createdPoliciesCount: number;
              isActive: boolean;
              owner: PublicKey;
              padding: number[];
              tokenAccount: PublicKey;
              tokenMint: PublicKey;
              updatedAt: BN;
          };
          publicKey: PublicKey;
      }[],
  >

  Retrieves all user payment accounts owned by a specific user.

  Parameters

  • owner: PublicKey

    Public key of the user

  Returns Promise<
      {
          account: {
              activePoliciesCount: number;
              bump: number;
              createdAt: BN;
              createdPoliciesCount: number;
              isActive: boolean;
              owner: PublicKey;
              padding: number[];
              tokenAccount: PublicKey;
              tokenMint: PublicKey;
              updatedAt: BN;
          };
          publicKey: PublicKey;
      }[],
  >

  Array of user payment accounts owned by the specified user

getConfigPda

• getConfigPda(): PdaResult

  Gets the Program Configuration PDA.

  Returns PdaResult

  PdaResult containing the PDA address and bump

getCreateMilestonePolicyInstruction

• getCreateMilestonePolicyInstruction(
      tokenMint: PublicKey,
      recipient: PublicKey,
      gateway: PublicKey,
      milestoneAmounts: BN[],
      milestoneTimestamps: BN[],
      releaseCondition: number,
      memo: number[],
  ): Promise<TransactionInstruction>

  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.

  Parameters

  • tokenMint: PublicKey

    Public key of the token to be paid

  • recipient: PublicKey

    Public key that receives the payments

  • gateway: PublicKey

    Public key of the gateway that will execute payments

  • milestoneAmounts: BN[]

    Array of amounts for each milestone (up to 4)

  • milestoneTimestamps: BN[]

    Array of timestamps when each milestone is due

  • releaseCondition: number

    Bitmap: bit0=check due date, bit1=gateway signer, bit2=owner signer, bit3=recipient signer. Bits 1-3 mutually exclusive.

  • memo: number[]

    Memo bytes to include with payments (max 64 bytes)

  Returns Promise<TransactionInstruction>

  Transaction instruction to create the milestone payment policy

getCreatePayAsYouGoPolicyInstruction

• getCreatePayAsYouGoPolicyInstruction(
      tokenMint: PublicKey,
      recipient: PublicKey,
      gateway: PublicKey,
      maxAmountPerPeriod: BN,
      maxChunkAmount: BN,
      periodLengthSeconds: BN,
      memo: number[],
  ): Promise<TransactionInstruction>

  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.

  Parameters

  • tokenMint: PublicKey

    Public key of the token to be paid

  • recipient: PublicKey

    Public key that receives the payments

  • gateway: PublicKey

    Public key of the gateway that will execute payments

  • maxAmountPerPeriod: BN

    Maximum amount allowed per period

  • maxChunkAmount: BN

    Maximum amount that can be claimed in a single payment

  • periodLengthSeconds: BN

    Length of each period in seconds

  • memo: number[]

    Memo bytes to include with payments (max 64 bytes)

  Returns Promise<TransactionInstruction>

  Transaction instruction to create the pay-as-you-go payment policy

getCreateSubscriptionPolicyInstruction

• getCreateSubscriptionPolicyInstruction(
      tokenMint: PublicKey,
      recipient: PublicKey,
      gateway: PublicKey,
      amount: BN,
      autoRenew: boolean,
      maxRenewals: number | null,
      paymentFrequency: DecodeEnum,
      memo: number[],
      startTime?: BN | null,
  ): Promise<TransactionInstruction>

  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.

  Parameters

  • tokenMint: PublicKey

    Public key of the token to be paid

  • recipient: PublicKey

    Public key that receives the payments

  • gateway: PublicKey

    Public key of the gateway that will execute payments

  • amount: BN

    Amount to pay per interval (in smallest token units)

  • autoRenew: boolean

    Whether the subscription should auto-renew

  • maxRenewals: number | null

    Maximum number of renewals allowed (null for unlimited)

  • paymentFrequency: DecodeEnum

    How often payments should occur

  • memo: number[]

    Memo bytes to include with payments (max 64 bytes)

  • OptionalstartTime: BN | null

    When the first payment should occur (defaults to now)

  Returns Promise<TransactionInstruction>

  Transaction instruction to create the subscription payment policy

getGatewayPda

• getGatewayPda(gatewayAuthority: PublicKey): PdaResult

  Gets a Payment Gateway PDA for the specified authority.

  Parameters

  • gatewayAuthority: PublicKey

    Public key of the gateway authority

  Returns PdaResult

  PdaResult containing the PDA address and bump

getPaymentGateway

• getPaymentGateway(
      gatewayAddress: PublicKey,
  ): Promise<
      | {
          authority: PublicKey;
          bump: number;
          createdAt: BN;
          customProtocolFeeBps: number;
          featureFlags: number;
          feeRecipient: PublicKey;
          gatewayFeeBps: number;
          isActive: boolean;
          name: number[];
          padding: number[];
          padding1: BN;
          referralAllocationBps: number;
          referralTiersBps: number[];
          signer: PublicKey;
          url: number[];
      }
      | null,
  >

  Fetches a specific payment gateway account by its address.

  Parameters

  • gatewayAddress: PublicKey

    Public key of the payment gateway account

  Returns Promise<
      | {
          authority: PublicKey;
          bump: number;
          createdAt: BN;
          customProtocolFeeBps: number;
          featureFlags: number;
          feeRecipient: PublicKey;
          gatewayFeeBps: number;
          isActive: boolean;
          name: number[];
          padding: number[];
          padding1: BN;
          referralAllocationBps: number;
          referralTiersBps: number[];
          signer: PublicKey;
          url: number[];
      }
      | null,
  >

  The payment gateway account data or null if not found

getPaymentPoliciesByGateway

• getPaymentPoliciesByGateway(
      gateway: PublicKey,
  ): Promise<
      {
          account: {
              bump: number;
              createdAt: BN;
              gateway: PublicKey;
              memo: number[];
              padding: number[];
              paymentCount: number;
              policyId: number;
              policyType: DecodeEnum<
                  {
                      kind: "enum";
                      variants: [
                          {
                              fields: [
                                  { name: "amount"; type: "u64" },
                                  { name: "autoRenew"; type: "bool" },
                                  { name: "maxRenewals"; type: { option: ... } },
                                  { name: "paymentFrequency"; type: { defined: ... } },
                                  { name: "nextPaymentDue"; type: "i64" },
                                  { name: "padding"; type: { array: ... } },
                              ];
                              name: "subscription";
                          },
                          {
                              fields: [
                                  { name: "milestoneAmounts"; type: { array: ... } },
                                  { name: "milestoneTimestamps"; type: { array: ... } },
                                  { name: "currentMilestone"; type: "u8" },
                                  { name: "releaseCondition"; type: "u8" },
                                  { name: "totalMilestones"; type: "u8" },
                                  { name: "escrowAmount"; type: "u64" },
                                  { name: "padding"; type: { array: ... } },
                              ];
                              name: "milestone";
                          },
                          {
                              fields: [
                                  { name: "maxAmountPerPeriod"; type: "u64" },
                                  { name: "maxChunkAmount"; type: "u64" },
                                  { name: "periodLengthSeconds"; type: "u64" },
                                  { name: "currentPeriodStart"; type: "i64" },
                                  { name: "currentPeriodTotal"; type: "u64" },
                                  { name: "padding"; type: { array: ... } },
                              ];
                              name: "payAsYouGo";
                          },
                      ];
                  },
                  DecodedHelper<
                      [
                          {
                              docs: [
                                  "An event that is thrown when a gateway fee bps is changed",
                              ];
                              name: "gatewayFeeBpsChanged";
                              type: {
                                  fields: [
                                      { name: ...; type: ... },
                                      { name: ...; type: ... },
                                      { name: ...; type: ... },
                                  ];
                                  kind: "struct";
                              };
                          },
                          {
                              docs: [
                                  "An event that is thrown when a gateway fee recipient is changed",
                              ];
                              name: "gatewayFeeRecipientChanged";
                              type: {
                                  fields: [
                                      { name: ...; type: ... },
                                      { name: ...; type: ... },
                                      { name: ...; type: ... },
                                  ];
                                  kind: "struct";
                              };
                          },
                          {
                              docs: ["An event that is thrown when a gateway signer is changed"];
                              name: "gatewaySignerChanged";
                              type: {
                                  fields: [
                                      { name: ...; type: ... },
                                      { name: ...; type: ... },
                                      { name: ...; type: ... },
                                  ];
                                  kind: "struct";
                              };
                          },
                      ],
                      EmptyDefined,
                  >,
              >;
              recipient: PublicKey;
              status: DecodeEnum<
                  { kind: "enum"; variants: [{ name: "active" }, { name: "paused" }] },
                  DecodedHelper<
                      [
                          {
                              docs: [
                                  "An event that is thrown when a gateway fee bps is changed",
                              ];
                              name: "gatewayFeeBpsChanged";
                              type: {
                                  fields: [
                                      { name: ...; type: ... },
                                      { name: ...; type: ... },
                                      { name: ...; type: ... },
                                  ];
                                  kind: "struct";
                              };
                          },
                          {
                              docs: [
                                  "An event that is thrown when a gateway fee recipient is changed",
                              ];
                              name: "gatewayFeeRecipientChanged";
                              type: {
                                  fields: [
                                      { name: ...; type: ... },
                                      { name: ...; type: ... },
                                      { name: ...; type: ... },
                                  ];
                                  kind: "struct";
                              };
                          },
                          {
                              docs: ["An event that is thrown when a gateway signer is changed"];
                              name: "gatewaySignerChanged";
                              type: {
                                  fields: [
                                      { name: ...; type: ... },
                                      { name: ...; type: ... },
                                      { name: ...; type: ... },
                                  ];
                                  kind: "struct";
                              };
                          },
                      ],
                      EmptyDefined,
                  >,
              >;
              totalPaid: BN;
              updatedAt: BN;
              userPayment: PublicKey;
          };
          publicKey: PublicKey;
      }[],
  >

  Retrieves all payment policies executed by the specified gateway.

  Parameters

  • gateway: PublicKey

    Public key of the payment gateway

  Returns Promise<
      {
          account: {
              bump: number;
              createdAt: BN;
              gateway: PublicKey;
              memo: number[];
              padding: number[];
              paymentCount: number;
              policyId: number;
              policyType: DecodeEnum<
                  {
                      kind: "enum";
                      variants: [
                          {
                              fields: [
                                  { name: "amount"; type: "u64" },
                                  { name: "autoRenew"; type: "bool" },
                                  { name: "maxRenewals"; type: { option: ... } },
                                  { name: "paymentFrequency"; type: { defined: ... } },
                                  { name: "nextPaymentDue"; type: "i64" },
                                  { name: "padding"; type: { array: ... } },
                              ];
                              name: "subscription";
                          },
                          {
                              fields: [
                                  { name: "milestoneAmounts"; type: { array: ... } },
                                  { name: "milestoneTimestamps"; type: { array: ... } },
                                  { name: "currentMilestone"; type: "u8" },
                                  { name: "releaseCondition"; type: "u8" },
                                  { name: "totalMilestones"; type: "u8" },
                                  { name: "escrowAmount"; type: "u64" },
                                  { name: "padding"; type: { array: ... } },
                              ];
                              name: "milestone";
                          },
                          {
                              fields: [
                                  { name: "maxAmountPerPeriod"; type: "u64" },
                                  { name: "maxChunkAmount"; type: "u64" },
                                  { name: "periodLengthSeconds"; type: "u64" },
                                  { name: "currentPeriodStart"; type: "i64" },
                                  { name: "currentPeriodTotal"; type: "u64" },
                                  { name: "padding"; type: { array: ... } },
                              ];
                              name: "payAsYouGo";
                          },
                      ];
                  },
                  DecodedHelper<
                      [
                          {
                              docs: [
                                  "An event that is thrown when a gateway fee bps is changed",
                              ];
                              name: "gatewayFeeBpsChanged";
                              type: {
                                  fields: [
                                      { name: ...; type: ... },
                                      { name: ...; type: ... },
                                      { name: ...; type: ... },
                                  ];
                                  kind: "struct";
                              };
                          },
                          {
                              docs: [
                                  "An event that is thrown when a gateway fee recipient is changed",
                              ];
                              name: "gatewayFeeRecipientChanged";
                              type: {
                                  fields: [
                                      { name: ...; type: ... },
                                      { name: ...; type: ... },
                                      { name: ...; type: ... },
                                  ];
                                  kind: "struct";
                              };
                          },
                          {
                              docs: ["An event that is thrown when a gateway signer is changed"];
                              name: "gatewaySignerChanged";
                              type: {
                                  fields: [
                                      { name: ...; type: ... },
                                      { name: ...; type: ... },
                                      { name: ...; type: ... },
                                  ];
                                  kind: "struct";
                              };
                          },
                      ],
                      EmptyDefined,
                  >,
              >;
              recipient: PublicKey;
              status: DecodeEnum<
                  { kind: "enum"; variants: [{ name: "active" }, { name: "paused" }] },
                  DecodedHelper<
                      [
                          {
                              docs: [
                                  "An event that is thrown when a gateway fee bps is changed",
                              ];
                              name: "gatewayFeeBpsChanged";
                              type: {
                                  fields: [
                                      { name: ...; type: ... },
                                      { name: ...; type: ... },
                                      { name: ...; type: ... },
                                  ];
                                  kind: "struct";
                              };
                          },
                          {
                              docs: [
                                  "An event that is thrown when a gateway fee recipient is changed",
                              ];
                              name: "gatewayFeeRecipientChanged";
                              type: {
                                  fields: [
                                      { name: ...; type: ... },
                                      { name: ...; type: ... },
                                      { name: ...; type: ... },
                                  ];
                                  kind: "struct";
                              };
                          },
                          {
                              docs: ["An event that is thrown when a gateway signer is changed"];
                              name: "gatewaySignerChanged";
                              type: {
                                  fields: [
                                      { name: ...; type: ... },
                                      { name: ...; type: ... },
                                      { name: ...; type: ... },
                                  ];
                                  kind: "struct";
                              };
                          },
                      ],
                      EmptyDefined,
                  >,
              >;
              totalPaid: BN;
              updatedAt: BN;
              userPayment: PublicKey;
          };
          publicKey: PublicKey;
      }[],
  >

  Array of payment policies executed by the gateway

getPaymentPoliciesByRecipient

• getPaymentPoliciesByRecipient(
      user: PublicKey,
  ): Promise<
      {
          account: {
              bump: number;
              createdAt: BN;
              gateway: PublicKey;
              memo: number[];
              padding: number[];
              paymentCount: number;
              policyId: number;
              policyType: DecodeEnum<
                  {
                      kind: "enum";
                      variants: [
                          {
                              fields: [
                                  { name: "amount"; type: "u64" },
                                  { name: "autoRenew"; type: "bool" },
                                  { name: "maxRenewals"; type: { option: ... } },
                                  { name: "paymentFrequency"; type: { defined: ... } },
                                  { name: "nextPaymentDue"; type: "i64" },
                                  { name: "padding"; type: { array: ... } },
                              ];
                              name: "subscription";
                          },
                          {
                              fields: [
                                  { name: "milestoneAmounts"; type: { array: ... } },
                                  { name: "milestoneTimestamps"; type: { array: ... } },
                                  { name: "currentMilestone"; type: "u8" },
                                  { name: "releaseCondition"; type: "u8" },
                                  { name: "totalMilestones"; type: "u8" },
                                  { name: "escrowAmount"; type: "u64" },
                                  { name: "padding"; type: { array: ... } },
                              ];
                              name: "milestone";
                          },
                          {
                              fields: [
                                  { name: "maxAmountPerPeriod"; type: "u64" },
                                  { name: "maxChunkAmount"; type: "u64" },
                                  { name: "periodLengthSeconds"; type: "u64" },
                                  { name: "currentPeriodStart"; type: "i64" },
                                  { name: "currentPeriodTotal"; type: "u64" },
                                  { name: "padding"; type: { array: ... } },
                              ];
                              name: "payAsYouGo";
                          },
                      ];
                  },
                  DecodedHelper<
                      [
                          {
                              docs: [
                                  "An event that is thrown when a gateway fee bps is changed",
                              ];
                              name: "gatewayFeeBpsChanged";
                              type: {
                                  fields: [
                                      { name: ...; type: ... },
                                      { name: ...; type: ... },
                                      { name: ...; type: ... },
                                  ];
                                  kind: "struct";
                              };
                          },
                          {
                              docs: [
                                  "An event that is thrown when a gateway fee recipient is changed",
                              ];
                              name: "gatewayFeeRecipientChanged";
                              type: {
                                  fields: [
                                      { name: ...; type: ... },
                                      { name: ...; type: ... },
                                      { name: ...; type: ... },
                                  ];
                                  kind: "struct";
                              };
                          },
                          {
                              docs: ["An event that is thrown when a gateway signer is changed"];
                              name: "gatewaySignerChanged";
                              type: {
                                  fields: [
                                      { name: ...; type: ... },
                                      { name: ...; type: ... },
                                      { name: ...; type: ... },
                                  ];
                                  kind: "struct";
                              };
                          },
                      ],
                      EmptyDefined,
                  >,
              >;
              recipient: PublicKey;
              status: DecodeEnum<
                  { kind: "enum"; variants: [{ name: "active" }, { name: "paused" }] },
                  DecodedHelper<
                      [
                          {
                              docs: [
                                  "An event that is thrown when a gateway fee bps is changed",
                              ];
                              name: "gatewayFeeBpsChanged";
                              type: {
                                  fields: [
                                      { name: ...; type: ... },
                                      { name: ...; type: ... },
                                      { name: ...; type: ... },
                                  ];
                                  kind: "struct";
                              };
                          },
                          {
                              docs: [
                                  "An event that is thrown when a gateway fee recipient is changed",
                              ];
                              name: "gatewayFeeRecipientChanged";
                              type: {
                                  fields: [
                                      { name: ...; type: ... },
                                      { name: ...; type: ... },
                                      { name: ...; type: ... },
                                  ];
                                  kind: "struct";
                              };
                          },
                          {
                              docs: ["An event that is thrown when a gateway signer is changed"];
                              name: "gatewaySignerChanged";
                              type: {
                                  fields: [
                                      { name: ...; type: ... },
                                      { name: ...; type: ... },
                                      { name: ...; type: ... },
                                  ];
                                  kind: "struct";
                              };
                          },
                      ],
                      EmptyDefined,
                  >,
              >;
              totalPaid: BN;
              updatedAt: BN;
              userPayment: PublicKey;
          };
          publicKey: PublicKey;
      }[],
  >

  Retrieves all payment policies where the specified user is the recipient.

  Parameters

  • user: PublicKey

    Public key of the payment recipient

  Returns Promise<
      {
          account: {
              bump: number;
              createdAt: BN;
              gateway: PublicKey;
              memo: number[];
              padding: number[];
              paymentCount: number;
              policyId: number;
              policyType: DecodeEnum<
                  {
                      kind: "enum";
                      variants: [
                          {
                              fields: [
                                  { name: "amount"; type: "u64" },
                                  { name: "autoRenew"; type: "bool" },
                                  { name: "maxRenewals"; type: { option: ... } },
                                  { name: "paymentFrequency"; type: { defined: ... } },
                                  { name: "nextPaymentDue"; type: "i64" },
                                  { name: "padding"; type: { array: ... } },
                              ];
                              name: "subscription";
                          },
                          {
                              fields: [
                                  { name: "milestoneAmounts"; type: { array: ... } },
                                  { name: "milestoneTimestamps"; type: { array: ... } },
                                  { name: "currentMilestone"; type: "u8" },
                                  { name: "releaseCondition"; type: "u8" },
                                  { name: "totalMilestones"; type: "u8" },
                                  { name: "escrowAmount"; type: "u64" },
                                  { name: "padding"; type: { array: ... } },
                              ];
                              name: "milestone";
                          },
                          {
                              fields: [
                                  { name: "maxAmountPerPeriod"; type: "u64" },
                                  { name: "maxChunkAmount"; type: "u64" },
                                  { name: "periodLengthSeconds"; type: "u64" },
                                  { name: "currentPeriodStart"; type: "i64" },
                                  { name: "currentPeriodTotal"; type: "u64" },
                                  { name: "padding"; type: { array: ... } },
                              ];
                              name: "payAsYouGo";
                          },
                      ];
                  },
                  DecodedHelper<
                      [
                          {
                              docs: [
                                  "An event that is thrown when a gateway fee bps is changed",
                              ];
                              name: "gatewayFeeBpsChanged";
                              type: {
                                  fields: [
                                      { name: ...; type: ... },
                                      { name: ...; type: ... },
                                      { name: ...; type: ... },
                                  ];
                                  kind: "struct";
                              };
                          },
                          {
                              docs: [
                                  "An event that is thrown when a gateway fee recipient is changed",
                              ];
                              name: "gatewayFeeRecipientChanged";
                              type: {
                                  fields: [
                                      { name: ...; type: ... },
                                      { name: ...; type: ... },
                                      { name: ...; type: ... },
                                  ];
                                  kind: "struct";
                              };
                          },
                          {
                              docs: ["An event that is thrown when a gateway signer is changed"];
                              name: "gatewaySignerChanged";
                              type: {
                                  fields: [
                                      { name: ...; type: ... },
                                      { name: ...; type: ... },
                                      { name: ...; type: ... },
                                  ];
                                  kind: "struct";
                              };
                          },
                      ],
                      EmptyDefined,
                  >,
              >;
              recipient: PublicKey;
              status: DecodeEnum<
                  { kind: "enum"; variants: [{ name: "active" }, { name: "paused" }] },
                  DecodedHelper<
                      [
                          {
                              docs: [
                                  "An event that is thrown when a gateway fee bps is changed",
                              ];
                              name: "gatewayFeeBpsChanged";
                              type: {
                                  fields: [
                                      { name: ...; type: ... },
                                      { name: ...; type: ... },
                                      { name: ...; type: ... },
                                  ];
                                  kind: "struct";
                              };
                          },
                          {
                              docs: [
                                  "An event that is thrown when a gateway fee recipient is changed",
                              ];
                              name: "gatewayFeeRecipientChanged";
                              type: {
                                  fields: [
                                      { name: ...; type: ... },
                                      { name: ...; type: ... },
                                      { name: ...; type: ... },
                                  ];
                                  kind: "struct";
                              };
                          },
                          {
                              docs: ["An event that is thrown when a gateway signer is changed"];
                              name: "gatewaySignerChanged";
                              type: {
                                  fields: [
                                      { name: ...; type: ... },
                                      { name: ...; type: ... },
                                      { name: ...; type: ... },
                                  ];
                                  kind: "struct";
                              };
                          },
                      ],
                      EmptyDefined,
                  >,
              >;
              totalPaid: BN;
              updatedAt: BN;
              userPayment: PublicKey;
          };
          publicKey: PublicKey;
      }[],
  >

  Array of payment policies where the user is the recipient