@ic-pay/icpay-sdk 1.3.61

package/README.md

@@ -0,0 +1,32 @@
+# ICPay SDK
+
+Official SDK for integrating Internet Computer payments with ICPay.
+
+## Installation
+
+Using pnpm:
+```bash
+pnpm add @ic-pay/icpay-sdk
+```
+
+Using yarn:
+```bash
+yarn add @ic-pay/icpay-sdk
+```
+
+Using npm:
+```bash
+npm install @ic-pay/icpay-sdk
+```
+
+## Documentation
+
+For full usage guides, configuration, API reference, and examples, see the ICPay documentation: [ICPay Docs](https://docs.icpay.org).
+
+## Basic Info
+
+- Works in browser and Node.js environments
+- TypeScript-ready with bundled types
+- Supports public (publishable key) and private (secret key) usage
+
+If you need help getting started, the step-by-step guides and examples on the [ICPay Docs](https://docs.icpay.org) cover common setups and advanced scenarios.

package/dist/declarations/icp-ledger/icp-ledger.did.d.ts

@@ -0,0 +1,82 @@
+export interface AccountIdentifier extends Array<number> {}
+export interface Tokens extends bigint {}
+export interface BlockIndex extends bigint {}
+export interface Memo extends bigint {}
+export interface SubAccount extends Array<number> {}
+export interface TimeStamp extends bigint {}
+export interface TransferFee extends bigint {}
+
+export interface AccountBalanceArgs {
+  account: AccountIdentifier;
+}
+
+export interface AccountBalanceArgsDfx {
+  account: string;
+}
+
+export interface TransferArgs {
+  to: AccountIdentifier;
+  fee: TransferFee;
+  memo: Memo;
+  from_subaccount?: SubAccount;
+  created_at_time?: TimeStamp;
+  amount: Tokens;
+}
+
+export interface TransferError {
+  BadFee?: { expected_fee: TransferFee };
+  BadBurn?: { min_burn_amount: Tokens };
+  InsufficientFunds?: { balance: Tokens };
+  TooOld?: null;
+  CreatedInFuture?: { ledger_time: TimeStamp };
+  TemporarilyUnavailable?: null;
+  Duplicate?: { duplicate_of: BlockIndex };
+  GenericError?: { error_code: number; message: string };
+}
+
+export interface TransferResult {
+  Ok?: BlockIndex;
+  Err?: TransferError;
+}
+
+export interface Block {
+  id: BlockIndex;
+  parent_hash?: Array<number>;
+  timestamp: TimeStamp;
+  transaction: {
+    Transfer: {
+      from: string;
+      to: string;
+      amount: Tokens;
+      fee?: TransferFee;
+      memo?: Array<number>;
+      created_at_time?: TimeStamp;
+    };
+  };
+}
+
+export interface ArchiveRange {
+  start: BlockIndex;
+  length: BlockIndex;
+  callback: (args: Array<Block>) => Promise<Array<Block>>;
+}
+
+export interface QueryBlocksArgs {
+  start: BlockIndex;
+  length: BlockIndex;
+}
+
+export interface QueryBlocksResponse {
+  blocks: Array<Block>;
+  archived_blocks: Array<ArchiveRange>;
+}
+
+export interface _SERVICE {
+  account_balance: (arg_0: AccountBalanceArgs) => Promise<Tokens>;
+  account_balance_dfx: (arg_0: AccountBalanceArgsDfx) => Promise<Tokens>;
+  account_transfer: (arg_0: TransferArgs) => Promise<TransferResult>;
+  query_blocks: (arg_0: QueryBlocksArgs) => Promise<QueryBlocksResponse>;
+}
+
+export declare const idlFactory: IDL.InterfaceFactory;
+export declare const init: (args: { IDL: typeof IDL }) => any[];

package/dist/declarations/icp-ledger/icp-ledger.did.js

@@ -0,0 +1,76 @@
+export const idlFactory = ({ IDL }) => {
+  const AccountIdentifier = IDL.Vec(IDL.Nat8);
+  const Tokens = IDL.Nat;
+  const BlockIndex = IDL.Nat;
+  const Memo = IDL.Nat64;
+  const SubAccount = IDL.Vec(IDL.Nat8);
+  const TimeStamp = IDL.Nat64;
+  const TransferFee = IDL.Nat;
+  const AccountBalanceArgs = IDL.Record({
+    account: AccountIdentifier,
+  });
+  const AccountBalanceArgsDfx = IDL.Record({
+    account: IDL.Text,
+  });
+  const TransferArgs = IDL.Record({
+    to: AccountIdentifier,
+    fee: TransferFee,
+    memo: Memo,
+    from_subaccount: IDL.Opt(SubAccount),
+    created_at_time: IDL.Opt(TimeStamp),
+    amount: Tokens,
+  });
+  const TransferError = IDL.Variant({
+    BadFee: IDL.Record({ expected_fee: TransferFee }),
+    BadBurn: IDL.Record({ min_burn_amount: Tokens }),
+    InsufficientFunds: IDL.Record({ balance: Tokens }),
+    TooOld: IDL.Null,
+    CreatedInFuture: IDL.Record({ ledger_time: TimeStamp }),
+    TemporarilyUnavailable: IDL.Null,
+    Duplicate: IDL.Record({ duplicate_of: BlockIndex }),
+    GenericError: IDL.Record({ error_code: IDL.Nat, message: IDL.Text }),
+  });
+  const TransferResult = IDL.Variant({
+    Ok: BlockIndex,
+    Err: TransferError,
+  });
+  const Block = IDL.Record({
+    id: IDL.Nat,
+    parent_hash: IDL.Opt(IDL.Vec(IDL.Nat8)),
+    timestamp: TimeStamp,
+    transaction: IDL.Record({
+      Transfer: IDL.Record({
+        from: IDL.Principal,
+        to: IDL.Principal,
+        amount: Tokens,
+        fee: IDL.Opt(TransferFee),
+        memo: IDL.Opt(IDL.Vec(IDL.Nat8)),
+        created_at_time: IDL.Opt(TimeStamp),
+      }),
+    }),
+  });
+  const ArchiveRange = IDL.Record({
+    start: IDL.Nat,
+    length: IDL.Nat,
+    callback: IDL.Func([IDL.Vec(Block)], [IDL.Vec(Block)], ['query']),
+  });
+  return IDL.Service({
+    account_balance: IDL.Func([AccountBalanceArgs], [Tokens], ['query']),
+    account_balance_dfx: IDL.Func([AccountBalanceArgsDfx], [Tokens], ['query']),
+    account_transfer: IDL.Func([TransferArgs], [TransferResult], []),
+    query_blocks: IDL.Func([
+      IDL.Record({
+        start: IDL.Nat,
+        length: IDL.Nat,
+      }),
+    ], [
+      IDL.Record({
+        blocks: IDL.Vec(Block),
+        archived_blocks: IDL.Vec(ArchiveRange),
+      }),
+    ], ['query']),
+  });
+};
+export const init = ({ IDL }) => {
+  return [];
+};

package/dist/declarations/icpay_canister_backend/icpay_canister_backend.did

@@ -0,0 +1,193 @@
+type Account = record {
+  account_canister_id : nat64;
+  platform_fee_percentage : nat16;
+  subaccount : opt blob;
+  wallet_address : text;
+  icp_account_identifier : opt text;
+  platform_fee_fixed : opt nat;
+  is_active : bool;
+  splits : vec SplitRule;
+};
+type AccountRecord = record { account_canister_id : nat64; account : Account };
+type CanisterMetrics = record {
+  total_accounts : nat32;
+  cycles_balance : nat64;
+  controllers : vec principal;
+  is_healthy : bool;
+  last_update_timestamp : nat64;
+  active_accounts : nat32;
+  memory_size_bytes : nat64;
+  total_transactions : nat32;
+  platform_wallet : text;
+};
+type Icrc21ConsentInfo = record {
+  metadata : Icrc21ConsentMessageMetadata;
+  consent_message : Icrc21ConsentMessage;
+};
+type Icrc21ConsentMessage = variant {
+  LineDisplayMessage : record { pages : vec Icrc21Page };
+  GenericDisplayMessage : text;
+};
+type Icrc21ConsentMessageMetadata = record {
+  utc_offset_minutes : opt int16;
+  language : text;
+};
+type Icrc21ConsentMessageRequest = record {
+  arg : blob;
+  method : text;
+  user_preferences : Icrc21ConsentMessageSpec;
+};
+type Icrc21ConsentMessageResponse = variant {
+  Ok : Icrc21ConsentInfo;
+  Err : Icrc21Error;
+};
+type Icrc21ConsentMessageSpec = record {
+  metadata : Icrc21ConsentMessageMetadata;
+  device_spec : opt Icrc21DeviceSpec;
+};
+type Icrc21DeviceSpec = variant {
+  GenericDisplay;
+  LineDisplay : record { characters_per_line : nat16; lines_per_page : nat16 };
+};
+type Icrc21Error = variant {
+  GenericError : record { description : text; error_code : nat64 };
+  InsufficientPayment : Icrc21ErrorInfo;
+  UnsupportedCanisterCall : Icrc21ErrorInfo;
+  ConsentMessageUnavailable : Icrc21ErrorInfo;
+};
+type Icrc21ErrorInfo = record { description : text };
+type Icrc21Page = record { lines : vec text };
+type LedgerTransactionNotification = record {
+  block_index : nat64;
+  ledger_canister_id : text;
+};
+type NotifyResult = record {
+  id : text;
+  status : TransactionStatus;
+  amount : nat;
+};
+type Payout = record {
+  id : nat;
+  fee : nat;
+  status : TransactionStatus;
+  account_canister_id : nat64;
+  to_principal : text;
+  to_subaccount : opt blob;
+  from_subaccount : blob;
+  icp_account_identifier : opt text;
+  timestamp_created : nat64;
+  index : opt nat64;
+  ledger_canister_id : text;
+  timestamp_completed : opt nat64;
+  amount : nat;
+  status_message : opt text;
+};
+type PublicTxStatus = record { status : TransactionStatus; amount : nat };
+type Refund = record {
+  status : TransactionStatus;
+  timestamp_platform_to_account : opt nat64;
+  account_canister_id : nat64;
+  original_tx_id : nat;
+  notify_processing : bool;
+  timestamp_created : nat64;
+  timestamp_to_sender : opt nat64;
+  ledger_canister_id : text;
+  amount : nat;
+  platform_refund_amount : nat;
+  index_to_sender : opt nat64;
+  index_platform_to_account : opt nat64;
+};
+type Result = variant { Ok; Err : text };
+type Result_1 = variant { Ok : NotifyResult; Err : text };
+type Result_2 = variant { Ok : Payout; Err : text };
+type Result_3 = variant { Ok : nat; Err : text };
+type Result_4 = variant { Ok : text; Err : text };
+type Split = record {
+  account_canister_id : nat64;
+  index_block : opt nat64;
+  timestamp : opt nat64;
+  account_percentage : nat16;
+  amount : nat;
+};
+type SplitRule = record { account_canister_id : nat64; percentage : nat16 };
+type Transaction = record {
+  id : nat;
+  status : TransactionStatus;
+  account_canister_id : nat64;
+  platform_fee_amount : nat;
+  transfer_fee : nat;
+  memo : opt blob;
+  timestamp_to_account : opt nat64;
+  notify_processing : bool;
+  timestamp : nat64;
+  index_received : opt nat64;
+  sender_principal_id : text;
+  account_amount : nat;
+  ledger_canister_id : text;
+  splits : vec Split;
+  timestamp_received : opt nat64;
+  amount : nat;
+};
+type TransactionFilter = record {
+  from_timestamp : opt nat64;
+  status : opt TransactionStatus;
+  account_canister_id : opt nat64;
+  from_id : opt nat;
+  offset : opt nat32;
+  limit : opt nat32;
+  to_timestamp : opt nat64;
+  ledger_canister_id : opt text;
+};
+type TransactionResult = record {
+  transactions : vec Transaction;
+  total_count : nat32;
+  has_more : bool;
+};
+type TransactionStatus = variant {
+  Failed : text;
+  Processed;
+  Received;
+  Completed;
+  Pending;
+};
+type WithdrawRequest = record {
+  recipient : text;
+  ledger_canister_id : text;
+  amount : nat;
+};
+service : () -> {
+  add_account : (nat64, Account) -> (Result);
+  get_account : (nat64) -> (opt Account) query;
+  get_account_transactions : (nat64, opt nat32, opt nat32) -> (
+      TransactionResult,
+    ) query;
+  get_canister_info : () -> (CanisterMetrics);
+  get_controller : () -> (principal) query;
+  get_controllers : () -> (vec principal) query;
+  get_ledger_transactions : (text, opt nat32, opt nat32) -> (
+      TransactionResult,
+    ) query;
+  get_payout : (nat) -> (opt Payout) query;
+  get_platform_wallet : () -> (text) query;
+  get_refund_by_original_tx_id : (nat) -> (opt Refund) query;
+  get_transaction : (nat) -> (opt Transaction) query;
+  get_transaction_status_public : (nat64, nat, opt nat64) -> (
+      opt PublicTxStatus,
+    ) query;
+  get_transactions : (TransactionFilter) -> (TransactionResult) query;
+  icrc21_canister_call_consent_message : (Icrc21ConsentMessageRequest) -> (
+      Icrc21ConsentMessageResponse,
+    );
+  initialize_controllers : () -> (Result);
+  list_accounts : () -> (vec AccountRecord) query;
+  notify_ledger_transaction : (LedgerTransactionNotification) -> (Result_1);
+  remove_account : (nat64) -> (Result);
+  request_payout : (nat64, text, nat) -> (Result_2);
+  request_refund : (nat) -> (Result_3);
+  retry_payout : (nat) -> (Result_2);
+  set_controller : (principal) -> (Result);
+  set_platform_wallet : (text) -> (Result);
+  update_account : (nat64, Account) -> (Result);
+  update_controllers : () -> (Result);
+  withdraw_funds : (WithdrawRequest) -> (Result_4);
+}

package/dist/declarations/icpay_canister_backend/icpay_canister_backend.did.d.ts

@@ -0,0 +1,219 @@
+import type { Principal } from '@dfinity/principal';
+import type { ActorMethod } from '@dfinity/agent';
+import type { IDL } from '@dfinity/candid';
+
+export interface Account {
+  'account_canister_id' : bigint,
+  'platform_fee_percentage' : number,
+  'subaccount' : [] | [Uint8Array | number[]],
+  'wallet_address' : string,
+  'icp_account_identifier' : [] | [string],
+  'platform_fee_fixed' : [] | [bigint],
+  'is_active' : boolean,
+  'splits' : Array<SplitRule>,
+}
+export interface AccountRecord {
+  'account_canister_id' : bigint,
+  'account' : Account,
+}
+export interface CanisterMetrics {
+  'total_accounts' : number,
+  'cycles_balance' : bigint,
+  'controllers' : Array<Principal>,
+  'is_healthy' : boolean,
+  'last_update_timestamp' : bigint,
+  'active_accounts' : number,
+  'memory_size_bytes' : bigint,
+  'total_transactions' : number,
+  'platform_wallet' : string,
+}
+export interface Icrc21ConsentInfo {
+  'metadata' : Icrc21ConsentMessageMetadata,
+  'consent_message' : Icrc21ConsentMessage,
+}
+export type Icrc21ConsentMessage = {
+    'LineDisplayMessage' : { 'pages' : Array<Icrc21Page> }
+  } |
+  { 'GenericDisplayMessage' : string };
+export interface Icrc21ConsentMessageMetadata {
+  'utc_offset_minutes' : [] | [number],
+  'language' : string,
+}
+export interface Icrc21ConsentMessageRequest {
+  'arg' : Uint8Array | number[],
+  'method' : string,
+  'user_preferences' : Icrc21ConsentMessageSpec,
+}
+export type Icrc21ConsentMessageResponse = { 'Ok' : Icrc21ConsentInfo } |
+  { 'Err' : Icrc21Error };
+export interface Icrc21ConsentMessageSpec {
+  'metadata' : Icrc21ConsentMessageMetadata,
+  'device_spec' : [] | [Icrc21DeviceSpec],
+}
+export type Icrc21DeviceSpec = { 'GenericDisplay' : null } |
+  {
+    'LineDisplay' : {
+      'characters_per_line' : number,
+      'lines_per_page' : number,
+    }
+  };
+export type Icrc21Error = {
+    'GenericError' : { 'description' : string, 'error_code' : bigint }
+  } |
+  { 'InsufficientPayment' : Icrc21ErrorInfo } |
+  { 'UnsupportedCanisterCall' : Icrc21ErrorInfo } |
+  { 'ConsentMessageUnavailable' : Icrc21ErrorInfo };
+export interface Icrc21ErrorInfo { 'description' : string }
+export interface Icrc21Page { 'lines' : Array<string> }
+export interface LedgerTransactionNotification {
+  'block_index' : bigint,
+  'ledger_canister_id' : string,
+}
+export interface NotifyResult {
+  'id' : string,
+  'status' : TransactionStatus,
+  'amount' : bigint,
+}
+export interface Payout {
+  'id' : bigint,
+  'fee' : bigint,
+  'status' : TransactionStatus,
+  'account_canister_id' : bigint,
+  'to_principal' : string,
+  'to_subaccount' : [] | [Uint8Array | number[]],
+  'from_subaccount' : Uint8Array | number[],
+  'icp_account_identifier' : [] | [string],
+  'timestamp_created' : bigint,
+  'index' : [] | [bigint],
+  'ledger_canister_id' : string,
+  'timestamp_completed' : [] | [bigint],
+  'amount' : bigint,
+  'status_message' : [] | [string],
+}
+export interface PublicTxStatus {
+  'status' : TransactionStatus,
+  'amount' : bigint,
+}
+export interface Refund {
+  'status' : TransactionStatus,
+  'timestamp_platform_to_account' : [] | [bigint],
+  'account_canister_id' : bigint,
+  'original_tx_id' : bigint,
+  'notify_processing' : boolean,
+  'timestamp_created' : bigint,
+  'timestamp_to_sender' : [] | [bigint],
+  'ledger_canister_id' : string,
+  'amount' : bigint,
+  'platform_refund_amount' : bigint,
+  'index_to_sender' : [] | [bigint],
+  'index_platform_to_account' : [] | [bigint],
+}
+export type Result = { 'Ok' : null } |
+  { 'Err' : string };
+export type Result_1 = { 'Ok' : NotifyResult } |
+  { 'Err' : string };
+export type Result_2 = { 'Ok' : Payout } |
+  { 'Err' : string };
+export type Result_3 = { 'Ok' : bigint } |
+  { 'Err' : string };
+export type Result_4 = { 'Ok' : string } |
+  { 'Err' : string };
+export interface Split {
+  'account_canister_id' : bigint,
+  'index_block' : [] | [bigint],
+  'timestamp' : [] | [bigint],
+  'account_percentage' : number,
+  'amount' : bigint,
+}
+export interface SplitRule {
+  'account_canister_id' : bigint,
+  'percentage' : number,
+}
+export interface Transaction {
+  'id' : bigint,
+  'status' : TransactionStatus,
+  'account_canister_id' : bigint,
+  'platform_fee_amount' : bigint,
+  'transfer_fee' : bigint,
+  'memo' : [] | [Uint8Array | number[]],
+  'timestamp_to_account' : [] | [bigint],
+  'notify_processing' : boolean,
+  'timestamp' : bigint,
+  'index_received' : [] | [bigint],
+  'sender_principal_id' : string,
+  'account_amount' : bigint,
+  'ledger_canister_id' : string,
+  'splits' : Array<Split>,
+  'timestamp_received' : [] | [bigint],
+  'amount' : bigint,
+}
+export interface TransactionFilter {
+  'from_timestamp' : [] | [bigint],
+  'status' : [] | [TransactionStatus],
+  'account_canister_id' : [] | [bigint],
+  'from_id' : [] | [bigint],
+  'offset' : [] | [number],
+  'limit' : [] | [number],
+  'to_timestamp' : [] | [bigint],
+  'ledger_canister_id' : [] | [string],
+}
+export interface TransactionResult {
+  'transactions' : Array<Transaction>,
+  'total_count' : number,
+  'has_more' : boolean,
+}
+export type TransactionStatus = { 'Failed' : string } |
+  { 'Processed' : null } |
+  { 'Received' : null } |
+  { 'Completed' : null } |
+  { 'Pending' : null };
+export interface WithdrawRequest {
+  'recipient' : string,
+  'ledger_canister_id' : string,
+  'amount' : bigint,
+}
+export interface _SERVICE {
+  'add_account' : ActorMethod<[bigint, Account], Result>,
+  'get_account' : ActorMethod<[bigint], [] | [Account]>,
+  'get_account_transactions' : ActorMethod<
+    [bigint, [] | [number], [] | [number]],
+    TransactionResult
+  >,
+  'get_canister_info' : ActorMethod<[], CanisterMetrics>,
+  'get_controller' : ActorMethod<[], Principal>,
+  'get_controllers' : ActorMethod<[], Array<Principal>>,
+  'get_ledger_transactions' : ActorMethod<
+    [string, [] | [number], [] | [number]],
+    TransactionResult
+  >,
+  'get_payout' : ActorMethod<[bigint], [] | [Payout]>,
+  'get_platform_wallet' : ActorMethod<[], string>,
+  'get_refund_by_original_tx_id' : ActorMethod<[bigint], [] | [Refund]>,
+  'get_transaction' : ActorMethod<[bigint], [] | [Transaction]>,
+  'get_transaction_status_public' : ActorMethod<
+    [bigint, bigint, [] | [bigint]],
+    [] | [PublicTxStatus]
+  >,
+  'get_transactions' : ActorMethod<[TransactionFilter], TransactionResult>,
+  'icrc21_canister_call_consent_message' : ActorMethod<
+    [Icrc21ConsentMessageRequest],
+    Icrc21ConsentMessageResponse
+  >,
+  'initialize_controllers' : ActorMethod<[], Result>,
+  'list_accounts' : ActorMethod<[], Array<AccountRecord>>,
+  'notify_ledger_transaction' : ActorMethod<
+    [LedgerTransactionNotification],
+    Result_1
+  >,
+  'remove_account' : ActorMethod<[bigint], Result>,
+  'request_payout' : ActorMethod<[bigint, string, bigint], Result_2>,
+  'request_refund' : ActorMethod<[bigint], Result_3>,
+  'retry_payout' : ActorMethod<[bigint], Result_2>,
+  'set_controller' : ActorMethod<[Principal], Result>,
+  'set_platform_wallet' : ActorMethod<[string], Result>,
+  'update_account' : ActorMethod<[bigint, Account], Result>,
+  'update_controllers' : ActorMethod<[], Result>,
+  'withdraw_funds' : ActorMethod<[WithdrawRequest], Result_4>,
+}
+export declare const idlFactory: IDL.InterfaceFactory;
+export declare const init: (args: { IDL: typeof IDL }) => IDL.Type[];