@swapkit/toolboxes 6.3.0 → 6.4.1

package/dist/types/evm/toolbox/evm.d.ts

@@ -172,7 +172,7 @@ export declare function ETHToolbox(params: EVMToolboxParams): {
         chainId?: bigint;
     }) => Promise<import("ethers").Authorization>) | undefined;
     signMessage: ((message: string | Uint8Array) => Promise<string>) | undefined;
-    signTypedData: (({ domain, types, value }: import("..").SignTypedDataParams) => Promise<string>) | undefined;
+    signTypedData: ((params: import("..").SignTypedDataParams) => Promise<string>) | undefined;
     transfer: ({ assetValue, memo, recipient, feeOptionKey, sender, sweep, ...tx }: import("..").EVMTransferParams) => Promise<string>;
     validateAddress: typeof import("./baseEVMToolbox").validateEVMAddress;
 };
@@ -344,7 +344,7 @@ export declare const ADIToolbox: ({ provider, ...toolboxParams }: EVMToolboxPara
         chainId?: bigint;
     }) => Promise<import("ethers").Authorization>) | undefined;
     signMessage: ((message: string | Uint8Array) => Promise<string>) | undefined;
-    signTypedData: (({ domain, types, value }: import("..").SignTypedDataParams) => Promise<string>) | undefined;
+    signTypedData: ((params: import("..").SignTypedDataParams) => Promise<string>) | undefined;
     transfer: ({ assetValue, memo, recipient, feeOptionKey, sender, sweep, ...tx }: import("..").EVMTransferParams) => Promise<string>;
     validateAddress: typeof import("./baseEVMToolbox").validateEVMAddress;
 };
@@ -516,7 +516,7 @@ export declare const ARBToolbox: ({ provider, ...toolboxParams }: EVMToolboxPara
         chainId?: bigint;
     }) => Promise<import("ethers").Authorization>) | undefined;
     signMessage: ((message: string | Uint8Array) => Promise<string>) | undefined;
-    signTypedData: (({ domain, types, value }: import("..").SignTypedDataParams) => Promise<string>) | undefined;
+    signTypedData: ((params: import("..").SignTypedDataParams) => Promise<string>) | undefined;
     transfer: ({ assetValue, memo, recipient, feeOptionKey, sender, sweep, ...tx }: import("..").EVMTransferParams) => Promise<string>;
     validateAddress: typeof import("./baseEVMToolbox").validateEVMAddress;
 };
@@ -688,7 +688,7 @@ export declare const ARCToolbox: ({ provider, ...toolboxParams }: EVMToolboxPara
         chainId?: bigint;
     }) => Promise<import("ethers").Authorization>) | undefined;
     signMessage: ((message: string | Uint8Array) => Promise<string>) | undefined;
-    signTypedData: (({ domain, types, value }: import("..").SignTypedDataParams) => Promise<string>) | undefined;
+    signTypedData: ((params: import("..").SignTypedDataParams) => Promise<string>) | undefined;
     transfer: ({ assetValue, memo, recipient, feeOptionKey, sender, sweep, ...tx }: import("..").EVMTransferParams) => Promise<string>;
     validateAddress: typeof import("./baseEVMToolbox").validateEVMAddress;
 };
@@ -860,7 +860,7 @@ export declare const AURORAToolbox: ({ provider, ...toolboxParams }: EVMToolboxP
         chainId?: bigint;
     }) => Promise<import("ethers").Authorization>) | undefined;
     signMessage: ((message: string | Uint8Array) => Promise<string>) | undefined;
-    signTypedData: (({ domain, types, value }: import("..").SignTypedDataParams) => Promise<string>) | undefined;
+    signTypedData: ((params: import("..").SignTypedDataParams) => Promise<string>) | undefined;
     transfer: ({ assetValue, memo, recipient, feeOptionKey, sender, sweep, ...tx }: import("..").EVMTransferParams) => Promise<string>;
     validateAddress: typeof import("./baseEVMToolbox").validateEVMAddress;
 };
@@ -1032,7 +1032,7 @@ export declare const AVAXToolbox: ({ provider, ...toolboxParams }: EVMToolboxPar
         chainId?: bigint;
     }) => Promise<import("ethers").Authorization>) | undefined;
     signMessage: ((message: string | Uint8Array) => Promise<string>) | undefined;
-    signTypedData: (({ domain, types, value }: import("..").SignTypedDataParams) => Promise<string>) | undefined;
+    signTypedData: ((params: import("..").SignTypedDataParams) => Promise<string>) | undefined;
     transfer: ({ assetValue, memo, recipient, feeOptionKey, sender, sweep, ...tx }: import("..").EVMTransferParams) => Promise<string>;
     validateAddress: typeof import("./baseEVMToolbox").validateEVMAddress;
 };
@@ -1210,7 +1210,7 @@ export declare const BASEToolbox: ({ provider, ...toolboxSignerParams }: EVMTool
         chainId?: bigint;
     }) => Promise<import("ethers").Authorization>) | undefined;
     signMessage: ((message: string | Uint8Array) => Promise<string>) | undefined;
-    signTypedData: (({ domain, types, value }: import("..").SignTypedDataParams) => Promise<string>) | undefined;
+    signTypedData: ((params: import("..").SignTypedDataParams) => Promise<string>) | undefined;
     transfer: ({ assetValue, memo, recipient, feeOptionKey, sender, sweep, ...tx }: import("..").EVMTransferParams) => Promise<string>;
     validateAddress: typeof import("./baseEVMToolbox").validateEVMAddress;
 };
@@ -1382,7 +1382,7 @@ export declare const BERAToolbox: ({ provider, ...toolboxParams }: EVMToolboxPar
         chainId?: bigint;
     }) => Promise<import("ethers").Authorization>) | undefined;
     signMessage: ((message: string | Uint8Array) => Promise<string>) | undefined;
-    signTypedData: (({ domain, types, value }: import("..").SignTypedDataParams) => Promise<string>) | undefined;
+    signTypedData: ((params: import("..").SignTypedDataParams) => Promise<string>) | undefined;
     transfer: ({ assetValue, memo, recipient, feeOptionKey, sender, sweep, ...tx }: import("..").EVMTransferParams) => Promise<string>;
     validateAddress: typeof import("./baseEVMToolbox").validateEVMAddress;
 };
@@ -1554,7 +1554,7 @@ export declare const BSCToolbox: ({ provider, ...toolboxParams }: EVMToolboxPara
         chainId?: bigint;
     }) => Promise<import("ethers").Authorization>) | undefined;
     signMessage: ((message: string | Uint8Array) => Promise<string>) | undefined;
-    signTypedData: (({ domain, types, value }: import("..").SignTypedDataParams) => Promise<string>) | undefined;
+    signTypedData: ((params: import("..").SignTypedDataParams) => Promise<string>) | undefined;
     transfer: ({ assetValue, memo, recipient, feeOptionKey, sender, sweep, ...tx }: import("..").EVMTransferParams) => Promise<string>;
     validateAddress: typeof import("./baseEVMToolbox").validateEVMAddress;
 };
@@ -1726,7 +1726,7 @@ export declare const BotanixToolbox: ({ provider, ...toolboxParams }: EVMToolbox
         chainId?: bigint;
     }) => Promise<import("ethers").Authorization>) | undefined;
     signMessage: ((message: string | Uint8Array) => Promise<string>) | undefined;
-    signTypedData: (({ domain, types, value }: import("..").SignTypedDataParams) => Promise<string>) | undefined;
+    signTypedData: ((params: import("..").SignTypedDataParams) => Promise<string>) | undefined;
     transfer: ({ assetValue, memo, recipient, feeOptionKey, sender, sweep, ...tx }: import("..").EVMTransferParams) => Promise<string>;
     validateAddress: typeof import("./baseEVMToolbox").validateEVMAddress;
 };
@@ -1898,7 +1898,7 @@ export declare const COREToolbox: ({ provider, ...toolboxParams }: EVMToolboxPar
         chainId?: bigint;
     }) => Promise<import("ethers").Authorization>) | undefined;
     signMessage: ((message: string | Uint8Array) => Promise<string>) | undefined;
-    signTypedData: (({ domain, types, value }: import("..").SignTypedDataParams) => Promise<string>) | undefined;
+    signTypedData: ((params: import("..").SignTypedDataParams) => Promise<string>) | undefined;
     transfer: ({ assetValue, memo, recipient, feeOptionKey, sender, sweep, ...tx }: import("..").EVMTransferParams) => Promise<string>;
     validateAddress: typeof import("./baseEVMToolbox").validateEVMAddress;
 };
@@ -2070,7 +2070,7 @@ export declare const CORNToolbox: ({ provider, ...toolboxParams }: EVMToolboxPar
         chainId?: bigint;
     }) => Promise<import("ethers").Authorization>) | undefined;
     signMessage: ((message: string | Uint8Array) => Promise<string>) | undefined;
-    signTypedData: (({ domain, types, value }: import("..").SignTypedDataParams) => Promise<string>) | undefined;
+    signTypedData: ((params: import("..").SignTypedDataParams) => Promise<string>) | undefined;
     transfer: ({ assetValue, memo, recipient, feeOptionKey, sender, sweep, ...tx }: import("..").EVMTransferParams) => Promise<string>;
     validateAddress: typeof import("./baseEVMToolbox").validateEVMAddress;
 };
@@ -2242,7 +2242,7 @@ export declare const CROToolbox: ({ provider, ...toolboxParams }: EVMToolboxPara
         chainId?: bigint;
     }) => Promise<import("ethers").Authorization>) | undefined;
     signMessage: ((message: string | Uint8Array) => Promise<string>) | undefined;
-    signTypedData: (({ domain, types, value }: import("..").SignTypedDataParams) => Promise<string>) | undefined;
+    signTypedData: ((params: import("..").SignTypedDataParams) => Promise<string>) | undefined;
     transfer: ({ assetValue, memo, recipient, feeOptionKey, sender, sweep, ...tx }: import("..").EVMTransferParams) => Promise<string>;
     validateAddress: typeof import("./baseEVMToolbox").validateEVMAddress;
 };
@@ -2414,7 +2414,7 @@ export declare const GNOToolbox: ({ provider, ...toolboxParams }: EVMToolboxPara
         chainId?: bigint;
     }) => Promise<import("ethers").Authorization>) | undefined;
     signMessage: ((message: string | Uint8Array) => Promise<string>) | undefined;
-    signTypedData: (({ domain, types, value }: import("..").SignTypedDataParams) => Promise<string>) | undefined;
+    signTypedData: ((params: import("..").SignTypedDataParams) => Promise<string>) | undefined;
     transfer: ({ assetValue, memo, recipient, feeOptionKey, sender, sweep, ...tx }: import("..").EVMTransferParams) => Promise<string>;
     validateAddress: typeof import("./baseEVMToolbox").validateEVMAddress;
 };
@@ -2586,7 +2586,7 @@ export declare const HOODToolbox: ({ provider, ...toolboxParams }: EVMToolboxPar
         chainId?: bigint;
     }) => Promise<import("ethers").Authorization>) | undefined;
     signMessage: ((message: string | Uint8Array) => Promise<string>) | undefined;
-    signTypedData: (({ domain, types, value }: import("..").SignTypedDataParams) => Promise<string>) | undefined;
+    signTypedData: ((params: import("..").SignTypedDataParams) => Promise<string>) | undefined;
     transfer: ({ assetValue, memo, recipient, feeOptionKey, sender, sweep, ...tx }: import("..").EVMTransferParams) => Promise<string>;
     validateAddress: typeof import("./baseEVMToolbox").validateEVMAddress;
 };
@@ -2758,7 +2758,7 @@ export declare const HYPEREVMToolbox: ({ provider, ...toolboxParams }: EVMToolbo
         chainId?: bigint;
     }) => Promise<import("ethers").Authorization>) | undefined;
     signMessage: ((message: string | Uint8Array) => Promise<string>) | undefined;
-    signTypedData: (({ domain, types, value }: import("..").SignTypedDataParams) => Promise<string>) | undefined;
+    signTypedData: ((params: import("..").SignTypedDataParams) => Promise<string>) | undefined;
     transfer: ({ assetValue, memo, recipient, feeOptionKey, sender, sweep, ...tx }: import("..").EVMTransferParams) => Promise<string>;
     validateAddress: typeof import("./baseEVMToolbox").validateEVMAddress;
 };
@@ -2930,7 +2930,7 @@ export declare const LINEAToolbox: ({ provider, ...toolboxParams }: EVMToolboxPa
         chainId?: bigint;
     }) => Promise<import("ethers").Authorization>) | undefined;
     signMessage: ((message: string | Uint8Array) => Promise<string>) | undefined;
-    signTypedData: (({ domain, types, value }: import("..").SignTypedDataParams) => Promise<string>) | undefined;
+    signTypedData: ((params: import("..").SignTypedDataParams) => Promise<string>) | undefined;
     transfer: ({ assetValue, memo, recipient, feeOptionKey, sender, sweep, ...tx }: import("..").EVMTransferParams) => Promise<string>;
     validateAddress: typeof import("./baseEVMToolbox").validateEVMAddress;
 };
@@ -3102,7 +3102,7 @@ export declare const MATICToolbox: ({ provider, ...toolboxParams }: EVMToolboxPa
         chainId?: bigint;
     }) => Promise<import("ethers").Authorization>) | undefined;
     signMessage: ((message: string | Uint8Array) => Promise<string>) | undefined;
-    signTypedData: (({ domain, types, value }: import("..").SignTypedDataParams) => Promise<string>) | undefined;
+    signTypedData: ((params: import("..").SignTypedDataParams) => Promise<string>) | undefined;
     transfer: ({ assetValue, memo, recipient, feeOptionKey, sender, sweep, ...tx }: import("..").EVMTransferParams) => Promise<string>;
     validateAddress: typeof import("./baseEVMToolbox").validateEVMAddress;
 };
@@ -3274,7 +3274,7 @@ export declare const MEGAETHToolbox: ({ provider, ...toolboxParams }: EVMToolbox
         chainId?: bigint;
     }) => Promise<import("ethers").Authorization>) | undefined;
     signMessage: ((message: string | Uint8Array) => Promise<string>) | undefined;
-    signTypedData: (({ domain, types, value }: import("..").SignTypedDataParams) => Promise<string>) | undefined;
+    signTypedData: ((params: import("..").SignTypedDataParams) => Promise<string>) | undefined;
     transfer: ({ assetValue, memo, recipient, feeOptionKey, sender, sweep, ...tx }: import("..").EVMTransferParams) => Promise<string>;
     validateAddress: typeof import("./baseEVMToolbox").validateEVMAddress;
 };
@@ -3446,7 +3446,7 @@ export declare const MONADToolbox: ({ provider, ...toolboxParams }: EVMToolboxPa
         chainId?: bigint;
     }) => Promise<import("ethers").Authorization>) | undefined;
     signMessage: ((message: string | Uint8Array) => Promise<string>) | undefined;
-    signTypedData: (({ domain, types, value }: import("..").SignTypedDataParams) => Promise<string>) | undefined;
+    signTypedData: ((params: import("..").SignTypedDataParams) => Promise<string>) | undefined;
     transfer: ({ assetValue, memo, recipient, feeOptionKey, sender, sweep, ...tx }: import("..").EVMTransferParams) => Promise<string>;
     validateAddress: typeof import("./baseEVMToolbox").validateEVMAddress;
 };
@@ -3618,7 +3618,7 @@ export declare const PLASMAToolbox: ({ provider, ...toolboxParams }: EVMToolboxP
         chainId?: bigint;
     }) => Promise<import("ethers").Authorization>) | undefined;
     signMessage: ((message: string | Uint8Array) => Promise<string>) | undefined;
-    signTypedData: (({ domain, types, value }: import("..").SignTypedDataParams) => Promise<string>) | undefined;
+    signTypedData: ((params: import("..").SignTypedDataParams) => Promise<string>) | undefined;
     transfer: ({ assetValue, memo, recipient, feeOptionKey, sender, sweep, ...tx }: import("..").EVMTransferParams) => Promise<string>;
     validateAddress: typeof import("./baseEVMToolbox").validateEVMAddress;
 };
@@ -3790,7 +3790,7 @@ export declare const SONICToolbox: ({ provider, ...toolboxParams }: EVMToolboxPa
         chainId?: bigint;
     }) => Promise<import("ethers").Authorization>) | undefined;
     signMessage: ((message: string | Uint8Array) => Promise<string>) | undefined;
-    signTypedData: (({ domain, types, value }: import("..").SignTypedDataParams) => Promise<string>) | undefined;
+    signTypedData: ((params: import("..").SignTypedDataParams) => Promise<string>) | undefined;
     transfer: ({ assetValue, memo, recipient, feeOptionKey, sender, sweep, ...tx }: import("..").EVMTransferParams) => Promise<string>;
     validateAddress: typeof import("./baseEVMToolbox").validateEVMAddress;
 };
@@ -3968,7 +3968,7 @@ export declare const UNIToolbox: ({ provider, ...toolboxSignerParams }: EVMToolb
         chainId?: bigint;
     }) => Promise<import("ethers").Authorization>) | undefined;
     signMessage: ((message: string | Uint8Array) => Promise<string>) | undefined;
-    signTypedData: (({ domain, types, value }: import("..").SignTypedDataParams) => Promise<string>) | undefined;
+    signTypedData: ((params: import("..").SignTypedDataParams) => Promise<string>) | undefined;
     transfer: ({ assetValue, memo, recipient, feeOptionKey, sender, sweep, ...tx }: import("..").EVMTransferParams) => Promise<string>;
     validateAddress: typeof import("./baseEVMToolbox").validateEVMAddress;
 };
@@ -4140,7 +4140,7 @@ export declare const XLayerToolbox: ({ provider, ...toolboxParams }: EVMToolboxP
         chainId?: bigint;
     }) => Promise<import("ethers").Authorization>) | undefined;
     signMessage: ((message: string | Uint8Array) => Promise<string>) | undefined;
-    signTypedData: (({ domain, types, value }: import("..").SignTypedDataParams) => Promise<string>) | undefined;
+    signTypedData: ((params: import("..").SignTypedDataParams) => Promise<string>) | undefined;
     transfer: ({ assetValue, memo, recipient, feeOptionKey, sender, sweep, ...tx }: import("..").EVMTransferParams) => Promise<string>;
     validateAddress: typeof import("./baseEVMToolbox").validateEVMAddress;
 };

package/dist/types/evm/toolbox/op.d.ts

@@ -184,7 +184,7 @@ export declare function createOPStackToolbox(chain: Chain.Optimism | Chain.Base
         chainId?: bigint;
     }) => Promise<Authorization>) | undefined;
     signMessage: ((message: string | Uint8Array) => Promise<string>) | undefined;
-    signTypedData: (({ domain, types, value }: import("..").SignTypedDataParams) => Promise<string>) | undefined;
+    signTypedData: ((params: import("..").SignTypedDataParams) => Promise<string>) | undefined;
     transfer: ({ assetValue, memo, recipient, feeOptionKey, sender, sweep, ...tx }: import("..").EVMTransferParams) => Promise<string>;
     validateAddress: typeof import("./baseEVMToolbox").validateEVMAddress;
 };
@@ -362,7 +362,7 @@ export declare const OPToolbox: ({ provider, ...toolboxSignerParams }: EVMToolbo
         chainId?: bigint;
     }) => Promise<Authorization>) | undefined;
     signMessage: ((message: string | Uint8Array) => Promise<string>) | undefined;
-    signTypedData: (({ domain, types, value }: import("..").SignTypedDataParams) => Promise<string>) | undefined;
+    signTypedData: ((params: import("..").SignTypedDataParams) => Promise<string>) | undefined;
     transfer: ({ assetValue, memo, recipient, feeOptionKey, sender, sweep, ...tx }: import("..").EVMTransferParams) => Promise<string>;
     validateAddress: typeof import("./baseEVMToolbox").validateEVMAddress;
 };

package/dist/types/hypercore/payin.d.ts

@@ -12,5 +12,4 @@ interface AssertSendAssetPayloadParams {
     submitTo: string;
     typedData: HyperCoreTypedData;
 }
-export declare function sanitizeTypedDataForSigner<TTypedData extends HyperCoreTypedData>(typedData: TTypedData): TTypedData;
 export declare function assertSendAssetPayload({ action, allowedEndpoints, expectedAmount, expectedDestination, expectedFromSubAccount, expectedSourceDex, expectedToken, submitTo, typedData, }: AssertSendAssetPayloadParams): void;

package/dist/types/lightspark/__tests__/vendorMissing.probe.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/lightspark/helpers.d.ts

@@ -0,0 +1,13 @@
+import type { LightsparkCurrencyAmount, LightsparkPaymentStatus } from "./types";
+export declare function parseMsats(value: string, context: string): bigint;
+export declare function msatsToSdkNumber(msats: bigint, context: string): number;
+export declare function tryCurrencyAmountToMsats(amount: LightsparkCurrencyAmount | null | undefined): bigint | undefined;
+export declare function currencyAmountToMsats(amount: LightsparkCurrencyAmount | null | undefined): bigint;
+export declare function defaultMaximumFeesMsats(amountMsats: bigint): bigint;
+export declare function mapPaymentStatus(status: string): LightsparkPaymentStatus;
+export declare function isTerminalPaymentStatus(status: string): boolean;
+export declare function isCompressedNodePublicKey(value: string): boolean;
+export declare function isPaymentHash(value: string): boolean;
+export declare function sleep(ms: number): Promise<void>;
+export declare function sdkErrorCode(error: unknown): string | undefined;
+export declare function sdkErrorMessage(error: unknown): string | undefined;

package/dist/types/lightspark/index.d.ts

@@ -0,0 +1,3 @@
+export { LIGHTNING_INVOICE_EXPIRY_SKEW_TOLERANCE_MAX_MS, LIGHTNING_INVOICE_EXPIRY_SKEW_TOLERANCE_MS, } from "./invoiceAssert";
+export { getLightsparkToolbox } from "./toolbox";
+export type * from "./types";

package/dist/types/lightspark/invoiceAssert.d.ts

@@ -0,0 +1,18 @@
+import type { LightsparkDecodedInvoice } from "./types";
+export declare const LIGHTNING_INVOICE_EXPIRY_SKEW_TOLERANCE_MS = 60000;
+export declare const LIGHTNING_INVOICE_EXPIRY_SKEW_TOLERANCE_MAX_MS = 600000;
+export declare function assertPayableLightningInvoice({ decoded, expectedDestinationPublicKey, expectedNetwork, nowMs, skewToleranceMs, }: {
+    decoded: LightsparkDecodedInvoice;
+    expectedDestinationPublicKey?: string;
+    expectedNetwork: string;
+    nowMs: number;
+    skewToleranceMs: number;
+}): void;
+export declare function resolveLightningPaymentAmountMsats({ amountMsats, invoiceAmountMsats, paymentHash, }: {
+    amountMsats?: string;
+    invoiceAmountMsats: bigint;
+    paymentHash: string;
+}): {
+    payAmountMsats: bigint;
+    zeroAmountInvoice: boolean;
+};

package/dist/types/lightspark/toolbox.d.ts

@@ -0,0 +1,13 @@
+import type { LightsparkBalance, LightsparkCreateInvoiceParams, LightsparkCreateInvoiceResult, LightsparkCreateTestModeInvoiceParams, LightsparkDecodedInvoice, LightsparkListTransactionsParams, LightsparkPayInvoiceParams, LightsparkPayInvoiceResult, LightsparkSendPaymentParams, LightsparkSendPaymentResult, LightsparkToolboxParams, LightsparkTrackingOutcome, LightsparkTransactionStatusParams, LightsparkTransactionSummary } from "./types";
+export declare function getLightsparkToolbox(params: LightsparkToolboxParams): {
+    createInvoice: ({ amountMsats, memo, expirySecs, }: LightsparkCreateInvoiceParams) => Promise<LightsparkCreateInvoiceResult>;
+    createTestModeInvoice: ({ amountMsats, memo, }: LightsparkCreateTestModeInvoiceParams) => Promise<{
+        encodedInvoice: string;
+    }>;
+    decodeInvoice: (invoice: string) => Promise<LightsparkDecodedInvoice>;
+    getBalance: () => Promise<LightsparkBalance>;
+    getTransactionStatus: ({ transactionId, paymentHash: rawPaymentHash, attempts, intervalMs, }: LightsparkTransactionStatusParams) => Promise<LightsparkTrackingOutcome>;
+    listTransactions: ({ numTransactions, afterDate, }?: LightsparkListTransactionsParams) => Promise<LightsparkTransactionSummary[]>;
+    payInvoice: ({ invoice, amountMsats, maximumFeesMsats, destinationPublicKey, timeoutSecs, attempts, intervalMs, expirySkewToleranceMs, }: LightsparkPayInvoiceParams) => Promise<LightsparkPayInvoiceResult>;
+    sendPayment: ({ destinationPublicKey, amountMsats, maximumFeesMsats, timeoutSecs, attempts, intervalMs, }: LightsparkSendPaymentParams) => Promise<LightsparkSendPaymentResult>;
+};

package/dist/types/lightspark/types.d.ts

@@ -0,0 +1,196 @@
+export type LightsparkCurrencyAmount = {
+    originalValue: number;
+    originalUnit: string;
+};
+export type LightsparkSdkInvoiceData = {
+    encodedPaymentRequest: string;
+    bitcoinNetwork: string;
+    paymentHash: string;
+    amount: LightsparkCurrencyAmount;
+    createdAt: string;
+    expiresAt: string;
+    destination: {
+        publicKey?: string | null;
+    };
+    memo?: string | null;
+};
+export type LightsparkSdkInvoice = {
+    id: string;
+    status: string;
+    data: LightsparkSdkInvoiceData;
+    amountPaid?: LightsparkCurrencyAmount | null;
+};
+export type LightsparkSdkTransaction = {
+    id: string;
+    createdAt: string;
+    status: string;
+    amount: LightsparkCurrencyAmount;
+    typename: string;
+    resolvedAt?: string | null;
+    transactionHash?: string | null;
+    fees?: LightsparkCurrencyAmount | null;
+    paymentPreimage?: string | null;
+    failureReason?: string | null;
+    destinationId?: string | null;
+};
+export type LightsparkSdkNode = {
+    id: string;
+    bitcoinNetwork: string;
+    balances?: {
+        availableToSendBalance: LightsparkCurrencyAmount;
+    };
+    localBalance?: LightsparkCurrencyAmount;
+    remoteBalance?: LightsparkCurrencyAmount;
+};
+type LightsparkGraphClientMethods = {
+    decodeInvoice(encodedInvoice: string): Promise<LightsparkSdkInvoiceData>;
+    payInvoice(payerNodeId: string, encodedInvoice: string, maximumFeesMsats: number, timeoutSecs?: number, amountMsats?: number, idempotencyKey?: string): Promise<LightsparkSdkTransaction | undefined>;
+    sendPayment(payerNodeId: string, destinationPublicKey: string, timeoutSecs: number | undefined, amountMsats: number, maximumFeesMsats: number): Promise<LightsparkSdkTransaction | undefined>;
+    createInvoiceWithDetails(nodeId: string, amountMsats: number, memo: string, type?: undefined, expirySecs?: number): Promise<LightsparkSdkInvoice | undefined>;
+    createTestModeInvoice(localNodeId: string, amountMsats: number, memo?: string): Promise<string | null>;
+    getRecentTransactions(nodeId: string, numTransactions?: number, bitcoinNetwork?: string, afterDate?: string): Promise<LightsparkSdkTransaction[]>;
+    getTransaction(transactionId: string): Promise<LightsparkSdkTransaction | null | undefined>;
+    outgoingPaymentsForPaymentHash(paymentHash: string, statuses?: string[]): Promise<LightsparkSdkTransaction[]>;
+    invoiceForPaymentHash(paymentHash: string): Promise<LightsparkSdkInvoice | null>;
+    getLightningFeeEstimateForInvoice(nodeId: string, encodedPaymentRequest: string, amountMsats?: number): Promise<LightsparkCurrencyAmount>;
+    getLightningFeeEstimateForNode(nodeId: string, destinationNodePublicKey: string, amountMsats: number): Promise<LightsparkCurrencyAmount>;
+    loadNodeKey(nodeId: string, signingPrivateKeyOrAlias: {
+        key: string;
+    }): Promise<void>;
+};
+/** Implement getNodeById to avoid the optional vendor SDK; executeRawQuery uses its query builder. */
+export type LightsparkGraphClient = LightsparkGraphClientMethods & ({
+    getNodeById(nodeId: string): Promise<LightsparkSdkNode | null>;
+    executeRawQuery?(query: unknown): Promise<unknown>;
+} | {
+    getNodeById?(nodeId: string): Promise<LightsparkSdkNode | null>;
+    executeRawQuery(query: unknown): Promise<unknown>;
+});
+export type LightsparkToolboxParams = {
+    nodeId: string;
+    signingKey?: string;
+    apiUrl?: string;
+} & ({
+    clientId: string;
+    clientSecret: string;
+    client?: LightsparkGraphClient;
+} | {
+    clientId?: string;
+    clientSecret?: string;
+    client: LightsparkGraphClient;
+});
+export type LightsparkPaymentStatus = "PENDING" | "SUCCESS" | "FAILED";
+export type LightsparkTrackingStatus = LightsparkPaymentStatus | "NOT_FOUND" | "UNKNOWN";
+export type LightsparkPaymentOutcome = {
+    status: LightsparkPaymentStatus;
+    paymentHash?: string;
+    transactionId?: string;
+    amountMsats?: string;
+    feePaidMsats?: string;
+    preimage?: string;
+    failureReason?: string;
+};
+export type LightsparkPayInvoiceResult = LightsparkPaymentOutcome & {
+    paymentHash: string;
+    /**
+     * PENDING because an amountless payment cannot be matched to this request. Reconcile its actual
+     * amount against requestedAmountMsats before resending, even if tracking later reports SUCCESS.
+     */
+    reconciliationRequired?: {
+        reason: "AMOUNT_MISMATCH" | "AMOUNT_UNVERIFIABLE";
+        requestedAmountMsats: string;
+    };
+    /** The result belongs to an earlier payment; this call sent nothing. */
+    replayedPriorPayment?: true;
+};
+export type LightsparkSendPaymentResult = LightsparkPaymentOutcome & {
+    amountMsats: string;
+    destinationPublicKey: string;
+    /**
+     * ISO-8601 send time minus LIGHTNING_INVOICE_EXPIRY_SKEW_TOLERANCE_MS. Pass as afterDate to
+     * listTransactions and match createdAt, amountMsats and typename before retrying an unknown send.
+     * destinationId is an entity id, so it cannot be compared with destinationPublicKey.
+     */
+    sentAfter: string;
+};
+export type LightsparkTrackingOutcome = Omit<LightsparkPaymentOutcome, "status"> & {
+    status: LightsparkTrackingStatus;
+};
+export type LightsparkPayInvoiceParams = {
+    invoice: string;
+    amountMsats?: string;
+    maximumFeesMsats?: string;
+    destinationPublicKey?: string;
+    timeoutSecs?: number;
+    attempts?: number;
+    intervalMs?: number;
+    /**
+     * Expiry allowance in milliseconds, from 0 to LIGHTNING_INVOICE_EXPIRY_SKEW_TOLERANCE_MAX_MS.
+     * Defaults to LIGHTNING_INVOICE_EXPIRY_SKEW_TOLERANCE_MS.
+     */
+    expirySkewToleranceMs?: number;
+};
+export type LightsparkSendPaymentParams = {
+    destinationPublicKey: string;
+    amountMsats: string;
+    maximumFeesMsats?: string;
+    timeoutSecs?: number;
+    attempts?: number;
+    intervalMs?: number;
+};
+export type LightsparkCreateInvoiceParams = {
+    amountMsats: string;
+    memo?: string;
+    expirySecs?: number;
+};
+export type LightsparkCreateInvoiceResult = {
+    encodedInvoice: string;
+    paymentHash: string;
+    amountMsats: string;
+    createdAt: string;
+    expiresAt: string;
+};
+export type LightsparkCreateTestModeInvoiceParams = {
+    amountMsats: string;
+    memo?: string;
+};
+export type LightsparkDecodedInvoice = {
+    paymentHash: string;
+    amountMsats: string;
+    network: string;
+    createdAt: string;
+    expiresAt: string;
+    destinationPublicKey?: string;
+    memo?: string;
+};
+export type LightsparkBalance = {
+    spendableMsats: string;
+    inboundCapacityMsats?: string;
+};
+export type LightsparkTransactionStatusParams = {
+    transactionId?: string;
+    paymentHash?: string;
+    attempts?: number;
+    intervalMs?: number;
+};
+export type LightsparkListTransactionsParams = {
+    numTransactions?: number;
+    /** ISO-8601 timestamp; pass `sentAfter` from a `sendPayment` result to bound a reconciliation scan. */
+    afterDate?: string;
+};
+/** A listTransactions row. Vendor enum values remain strings to support future SDK versions. */
+export type LightsparkTransactionSummary = {
+    id: string;
+    /** GraphQL type, e.g. "OutgoingPayment", "IncomingPayment" or "RoutingTransaction". */
+    typename: string;
+    /** Raw vendor status, including FUTURE_VALUE for an unrecognised status. */
+    status: string;
+    createdAt: string;
+    amountMsats?: string;
+    resolvedAt?: string;
+    /** BOLT11 payment hash for an OutgoingPayment, matching payInvoice results. */
+    transactionHash?: string;
+    /** Counterparty entity id (e.g. "GraphNode:0188..."); not a Lightning public key. */
+    destinationId?: string;
+};
+export {};

package/dist/types/starknet/types.d.ts

@@ -2,6 +2,7 @@ import type { DerivationPathArray, GenericTransferParams } from "@swapkit/helper
 import type { Account } from "starknet";
 export type StarknetToolboxParams = {
     signer?: Account;
+    walletDeploysAccount?: boolean;
 } | {
     phrase?: string;
     index?: number;

package/dist/types/sui/__tests__/grpcClientMock.d.ts

@@ -0,0 +1,37 @@
+export declare const SUI_COIN_TYPE = "0x2::sui::SUI";
+export declare const LONG_SUI_COIN_TYPE = "0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI";
+type MockCoin = {
+    balance: string;
+    digest: string;
+    objectId: string;
+    version: string;
+};
+type MockStatus = {
+    success: true;
+    error: null;
+} | {
+    success: false;
+    error: {
+        message: string;
+    };
+};
+export declare const suiRpc: {
+    balances: {
+        balance: string;
+        coinType: string;
+    }[];
+    calls: {
+        method: string;
+        params: unknown;
+    }[];
+    clientUrls: string[];
+    coinPages: Record<string, MockCoin[][]>;
+    count(method: string): number;
+    danglingNextPage: boolean;
+    error: Error | undefined;
+    reset(): void;
+    simulateStatus: MockStatus;
+};
+export declare function mockSuiGrpc(): void;
+export declare function restoreSuiGrpc(): void;
+export {};

package/package.json

@@ -1,8 +1,9 @@
 {
-  "dependencies": { "@swapkit/helpers": "6.1.2", "@swapkit/utxo-signer": "3.1.1" },
+  "dependencies": { "@swapkit/helpers": "6.3.0", "@swapkit/utxo-signer": "3.1.1" },
   "description": "SwapKit - Toolboxes",
   "devDependencies": {
     "@aptos-labs/ts-sdk": "7.0.1",
+    "@lightsparkdev/lightspark-sdk": "1.9.19",
     "@mysten/sui": "2.17.0",
     "@near-js/accounts": "2.5.1",
     "@near-js/crypto": "2.5.1",
@@ -60,6 +61,7 @@
     "./cosmos": { "default": "./dist/src/cosmos/index.js", "types": "./dist/types/cosmos/index.d.ts" },
     "./evm": { "default": "./dist/src/evm/index.js", "types": "./dist/types/evm/index.d.ts" },
     "./hypercore": { "default": "./dist/src/hypercore/index.js", "types": "./dist/types/hypercore/index.d.ts" },
+    "./lightspark": { "default": "./dist/src/lightspark/index.js", "types": "./dist/types/lightspark/index.d.ts" },
     "./near": { "default": "./dist/src/near/index.js", "types": "./dist/types/near/index.d.ts" },
     "./radix": { "default": "./dist/src/radix/index.js", "types": "./dist/types/radix/index.d.ts" },
     "./ripple": { "default": "./dist/src/ripple/index.js", "types": "./dist/types/ripple/index.d.ts" },
@@ -78,6 +80,7 @@
   "name": "@swapkit/toolboxes",
   "peerDependencies": {
     "@aptos-labs/ts-sdk": "7.0.1",
+    "@lightsparkdev/lightspark-sdk": "1.9.19",
     "@mysten/sui": "2.17.0",
     "@near-js/accounts": "2.5.1",
     "@near-js/crypto": "2.5.1",
@@ -121,6 +124,7 @@
     "ts-pattern": "5.9.0",
     "xrpl": "4.6.0"
   },
+  "peerDependenciesMeta": { "@lightsparkdev/lightspark-sdk": { "optional": true } },
   "publishConfig": { "access": "public" },
   "repository": { "type": "git", "url": "git+https://github.com/swapkit/SwapKit.git" },
   "scripts": {
@@ -131,5 +135,5 @@
     "type-check:go": "tsgo"
   },
   "type": "module",
-  "version": "6.3.0"
+  "version": "6.4.1"
 }

package/dist/chunk-ncc6qmj6.js

@@ -1 +0,0 @@
-import{$ as N,A as m,B as n,C as o,D as p,E as q,F as r,G as s,H as t,I as u,J as v,K as w,L as x,M as y,N as z,O as A,P as B,Q as C,R as D,S as E,T as F,U as G,V as H,W as I,X as J,Y as K,Z as L,_ as M,aa as O,ba as P,ca as Q,da as R,ea as S,fa as T,ga as U,o as a,p as b,q as c,r as d,s as e,t as f,u as g,v as h,w as i,x as j,y as k,z as l}from"./chunk-ygq25ce3.js";import"./chunk-xdkdc1f0.js";import"./chunk-exyqap7m.js";export{w as ADIToolbox,x as ARBToolbox,y as ARCToolbox,z as AURORAToolbox,A as AVAXToolbox,B as BASEToolbox,C as BERAToolbox,D as BSCToolbox,b as BaseEVMToolbox,E as BotanixToolbox,F as COREToolbox,G as CORNToolbox,H as CROToolbox,k as ContractAddress,v as ETHToolbox,I as GNOToolbox,J as HOODToolbox,K as HYPEREVMToolbox,L as LINEAToolbox,M as MATICToolbox,a as MAX_APPROVAL,N as MEGAETHToolbox,O as MONADToolbox,u as OPToolbox,P as PLASMAToolbox,Q as SONICToolbox,R as UNIToolbox,S as XLayerToolbox,e as createContract,t as createOPStackToolbox,j as getChecksumAddressFromAsset,f as getCreateContract,m as getCreateContractTxObject,i as getEIP1193SendTransaction,q as getEVMTxType,n as getEstimateGasPrices,T as getEvmToolbox,U as getEvmToolboxAsync,l as getTokenAddress,d as isBrowserProvider,p as isEIP1559Transaction,o as isEIP7702Transaction,g as isStateChangingCall,r as maxBigInt,s as scaleEIP1559Fees,h as toChecksumAddress,c as validateEVMAddress};