@kasufinance/kasu-sdk 2.10.1 → 2.10.3

package/src/domain/sponsored-calls.ts

@@ -1,11 +1,13 @@
 import { BigNumber, BigNumberish, constants, utils } from 'ethers';
 
+import { IERC20MetadataAbi__factory } from '../contracts/factories/IERC20MetadataAbi__factory';
 import { ILendingPoolManagerAbi__factory } from '../contracts/factories/ILendingPoolManagerAbi__factory';
 
 /**
- * The single-call `LendingPoolManager` requests a sponsored relay may carry,
- * encoded by the SDK so no application hand-builds calldata or hand-maps the
- * relay's `kind` for them.
+ * The single-call requests a sponsored relay may carry — the four
+ * `LendingPoolManager` requests, plus the stable asset's own `transfer` (P2P
+ * Send) — encoded by the SDK so no application hand-builds calldata or
+ * hand-maps the relay's `kind` for them.
  *
  * Every function here is PURE: addresses and ids in, `{ kind, call }` out.
  * Reading the chain (the shares a withdrawal is for) is the facade's job —
@@ -34,6 +36,11 @@ export const SPONSORED_CALL_KINDS = [
     'cancel_withdrawal',
     /** `LendingPoolManager.requestFixedTermDepositWithdrawal(pool, lockId)`. */
     'withdraw_at_expiry',
+    /**
+     * `stableAsset.transfer(to, amount)` — P2P Send, to the chain's stable
+     * asset rather than the manager. See {@link encodeStableTransfer}.
+     */
+    'transfer',
 ] as const;
 
 export type SponsoredCallKind = (typeof SPONSORED_CALL_KINDS)[number];
@@ -56,18 +63,26 @@ export interface SponsoredCall {
 const LENDING_POOL_MANAGER: utils.Interface =
     ILendingPoolManagerAbi__factory.createInterface();
 
-/** The `LendingPoolManager` function behind each kind. */
-const FUNCTION_OF: Readonly<Record<SponsoredCallKind, string>> = Object.freeze({
-    withdrawal: 'requestWithdrawal',
-    cancel_deposit: 'cancelDepositRequest',
-    cancel_withdrawal: 'cancelWithdrawalRequest',
-    withdraw_at_expiry: 'requestFixedTermDepositWithdrawal',
-});
+/** The generated ERC-20 interface — the `transfer` kind's one function. */
+const ERC20: utils.Interface = IERC20MetadataAbi__factory.createInterface();
+
+/** The kinds whose call goes to the `LendingPoolManager`. */
+type LendingPoolManagerKind = Exclude<SponsoredCallKind, 'transfer'>;
+
+/** The `LendingPoolManager` function behind each manager kind. */
+const FUNCTION_OF: Readonly<Record<LendingPoolManagerKind, string>> =
+    Object.freeze({
+        withdrawal: 'requestWithdrawal',
+        cancel_deposit: 'cancelDepositRequest',
+        cancel_withdrawal: 'cancelWithdrawalRequest',
+        withdraw_at_expiry: 'requestFixedTermDepositWithdrawal',
+    });
 
 /**
  * The 4-byte selector of each kind's function, DERIVED from the generated
- * `ILendingPoolManager` ABI — never typed in by hand, so an ABI change moves
- * it and the cross-check spec against the relay's own pins goes red.
+ * ABIs (`ILendingPoolManager`, and `IERC20Metadata` for `transfer`) — never
+ * typed in by hand, so an ABI change moves it and the cross-check spec
+ * against the relay's own pins goes red.
  */
 export const SPONSORED_CALL_SELECTORS: Readonly<
     Record<SponsoredCallKind, string>
@@ -80,6 +95,7 @@ export const SPONSORED_CALL_SELECTORS: Readonly<
     withdraw_at_expiry: LENDING_POOL_MANAGER.getSighash(
         FUNCTION_OF.withdraw_at_expiry,
     ),
+    transfer: ERC20.getSighash('transfer'),
 });
 
 /**
@@ -122,7 +138,7 @@ function toUint256(value: BigNumberish, code: string): BigNumber {
 }
 
 function encode(
-    kind: SponsoredCallKind,
+    kind: LendingPoolManagerKind,
     lendingPoolManager: string,
     args: readonly unknown[],
 ): SponsoredCall {
@@ -211,3 +227,53 @@ export function encodeWithdrawAtExpiryCall(
         toUint256(fixedTermDepositId, 'lock-id'),
     ]);
 }
+
+/**
+ * `stableAsset.transfer(to, amount)` — `transfer`: P2P Send of the chain's
+ * stable asset from the sender's own account (`msg.sender`) to `to`.
+ *
+ * `amount` is in the token's BASE units (6 decimals for USDC), and must be
+ * greater than zero. `to` must be a well-formed, non-zero address (a
+ * mixed-case one with a valid EIP-55 checksum). That is
+ * ALL this encoder judges, because it is all a pure function can know.
+ *
+ * The recipient POLICY is the relay's job and is deliberately not restated
+ * here: it refuses the sender's own account, the stable asset, the
+ * `LendingPoolManager`, the precompile range, any address with contract code
+ * (read on chain at submission), a sender our identity store does not hold
+ * as verified, and anything over the sender's daily count and amount caps.
+ * A call this encoder accepts can therefore still be refused — the app maps
+ * the relay's refusal codes to its own words.
+ *
+ * Pass `stableAsset` from the chain config (`CHAIN_CONFIGS[chain].stableAsset
+ * .address`) — the relay compares `to` against its own configured token and
+ * refuses any other contract.
+ */
+export function encodeStableTransfer(input: {
+    stableAsset: string;
+    to: string;
+    amount: BigNumberish;
+}): SponsoredCall {
+    assertAddress(input.stableAsset, 'stable-asset');
+    assertAddress(input.to, 'recipient');
+    // A mixed-case recipient carries an EIP-55 checksum, and one that does not
+    // match is a mistyped address: refuse it as `recipient` here rather than
+    // let the ABI coder throw its own error at the encode below.
+    try {
+        utils.getAddress(input.to);
+    } catch {
+        throw new SponsoredCallInputError('recipient');
+    }
+    if (BigNumber.from(input.to).isZero()) {
+        throw new SponsoredCallInputError('zero-recipient');
+    }
+    const amount = toUint256(input.amount, 'amount');
+    if (amount.isZero()) throw new SponsoredCallInputError('zero-amount');
+    return {
+        kind: 'transfer',
+        call: {
+            to: input.stableAsset,
+            data: ERC20.encodeFunctionData('transfer', [input.to, amount]),
+        },
+    };
+}

package/src/facade/strategies.ts

@@ -215,7 +215,9 @@ export class StrategiesFacade {
         return {
             id: pool.id,
             name: pool.poolName,
+            subheading: nonEmptyOrUndefined(pool.subheading),
             description: pool.description,
+            liteDescription: nonEmptyOrUndefined(pool.liteDescription),
             isActive: pool.isActive,
             apy: pool.apy,
             tvl: pool.totalValueLocked,
@@ -231,6 +233,17 @@ export class StrategiesFacade {
     }
 }
 
+/**
+ * A CMS text field as a string, or `undefined` when it is absent, not a
+ * string, or empty (blank included) — the CMS stores an emptied field as `''`, and an empty
+ * subheading must read as "none", not render an empty line.
+ */
+function nonEmptyOrUndefined(value: unknown): string | undefined {
+    return typeof value === 'string' && value.trim().length > 0
+        ? value
+        : undefined;
+}
+
 /**
  * A CMS "numeric" field as a finite number, or `null`. An empty or blank
  * string is UNAUTHORED, not zero.

package/src/facade/types.ts

@@ -1,7 +1,11 @@
 import { BigNumberish, BytesLike } from 'ethers';
 
 import { ContractAddresses, SdkConfigOptions } from '../sdk-config';
-import { LendingTotals, PoolOverview, TrancheData } from '../services/DataService/types';
+import {
+    LendingTotals,
+    PoolOverview,
+    TrancheData,
+} from '../services/DataService/types';
 import {
     PortfolioLendingPool,
     PortfolioSummary,
@@ -106,7 +110,17 @@ export interface KasuOptions {
 export interface Strategy {
     id: string;
     name: string;
+    /**
+     * The CMS subheading (the borrower type shown under the name). Absent when
+     * the record has none, or an empty one.
+     */
+    subheading?: string;
     description: string;
+    /**
+     * The CMS short description (`liteDescription`) for compact surfaces.
+     * Absent when the record has none, or an empty one.
+     */
+    liteDescription?: string;
     isActive: boolean;
     /** Weighted-average APY across tranches (decimal, e.g. 0.08 = 8 %). */
     apy: number;

package/src/flows/batch-submission.ts

@@ -349,7 +349,12 @@ export async function checkBatchOutcome<R extends ReceiptLike = ReceiptLike>(
         return 'unknown';
     }
     if (read.kind === 'reverted') return 'not-deposited';
-    if (read.kind !== 'mined' || typeof read.txHash !== 'string') {
+    // An empty hash is not an answer — `waitForMined` reads it the same way.
+    if (
+        read.kind !== 'mined' ||
+        typeof read.txHash !== 'string' ||
+        read.txHash === ''
+    ) {
         return 'unknown';
     }
     try {
@@ -367,9 +372,60 @@ export async function checkBatchOutcome<R extends ReceiptLike = ReceiptLike>(
 }
 
 // ---------------------------------------------------------------------------
-// One sponsored call — withdraw, cancel, withdraw at expiry
+// One sponsored call — withdraw, cancel, withdraw at expiry, transfer
 // ---------------------------------------------------------------------------
 
+/**
+ * `checkBatchOutcome` for ONE sponsored call — ONE status read, no polling —
+ * for an app's guard against sending the same request twice (a P2P transfer
+ * whose earlier submission ended PENDING, say):
+ *
+ * - `executed` — mined, and the receipt proves the sender's operation
+ *   succeeded (`proveUserOperationInReceipt`);
+ * - `not-executed` — definitively reverted (vendor status or the operation's
+ *   own flag);
+ * - `unknown` — anything else, including a read or receipt that failed, or a
+ *   receipt that does not show the sender's operation.
+ *
+ * Only `not-executed` may let a new attempt proceed unprompted; `executed`
+ * means the earlier one landed and the user should be told.
+ */
+export async function checkSponsoredCallOutcome<
+    R extends ReceiptLike = ReceiptLike,
+>(
+    transactionId: string,
+    expect: Omit<UserOperationProofExpectation, 'userOperationHash'>,
+    ports: Pick<BatchSubmissionPorts<R>, 'getStatus' | 'getReceipt'>,
+): Promise<'executed' | 'not-executed' | 'unknown'> {
+    let read: BatchStatusRead;
+    try {
+        read = await ports.getStatus(transactionId);
+    } catch {
+        return 'unknown';
+    }
+    if (read.kind === 'reverted') return 'not-executed';
+    // An empty hash is not an answer — `waitForMined` reads it the same way.
+    if (
+        read.kind !== 'mined' ||
+        typeof read.txHash !== 'string' ||
+        read.txHash === ''
+    ) {
+        return 'unknown';
+    }
+    try {
+        const receipt = await ports.getReceipt(read.txHash);
+        const proof = proveUserOperationInReceipt(receipt, {
+            ...expect,
+            userOperationHash: read.userOperationHash ?? null,
+        });
+        if (proof.kind === 'executed') return 'executed';
+        if (proof.kind === 'reverted') return 'not-executed';
+        return 'unknown';
+    } catch {
+        return 'unknown';
+    }
+}
+
 /**
  * `BatchSubmissionPorts` for ONE sponsored call: the same status, receipt and
  * clock ports — a relay client written for the deposit batch serves both —
@@ -409,9 +465,9 @@ export interface SponsoredCallSubmission<R extends ReceiptLike = ReceiptLike>
 }
 
 /**
- * `submitBatch` for ONE sponsored `LendingPoolManager` call — the body of a
- * `WithdrawFlow` `submitCall` port, and of an app's cancel or
- * withdraw-at-expiry action. Same post, same polling policy, same outcome
+ * `submitBatch` for ONE sponsored call — the body of a `WithdrawFlow`
+ * `submitCall` port, of an app's cancel or withdraw-at-expiry action, and of
+ * a P2P transfer (`encodeStableTransfer`). Same post, same polling policy, same outcome
  * table; the proof is `proveUserOperationInReceipt` (the sender's operation
  * succeeded) instead of the deposit proof, and an unproven receipt is
  * `call_unproven:<reason>`.
@@ -427,7 +483,8 @@ export interface SponsoredCallSubmission<R extends ReceiptLike = ReceiptLike>
  * The call is checked against its kind before anything is posted — a known
  * kind, exactly `{ to, data }`, and `data` opening with that kind's selector —
  * and a mismatch is `BatchSubmissionError('call_mismatch', 'failed')`: nothing
- * was sent. Build calls with `kasu.calls`, and this never fires.
+ * was sent. Build calls with `kasu.calls` (or `encodeStableTransfer`), and
+ * this never fires.
  *
  * As on the deposit path, nothing after the post ever produces `failed`.
  */

package/src/flows/index.ts

@@ -21,6 +21,7 @@ export type { BatchSubmissionOutcome } from './batch-errors';
 
 export {
     checkBatchOutcome,
+    checkSponsoredCallOutcome,
     DEFAULT_BATCH_POLLING_POLICY,
     submitBatch,
     submitSponsoredCall,