gondi 0.43.0 → 0.44.0

package/dist/src/blockchain.d.ts

@@ -58,6 +58,8 @@ export declare const zeroAddress: Address;
 export declare const zeroHash: Hash;
 export declare const zeroHex: HexString;
 export declare const REORG_SAFETY_BUFFER: bigint;
+/** How long a borrower's signed loan execution data stays valid once it is sent on-chain. */
+export declare const BORROWER_SIGNATURE_LIFETIME: bigint;
 /** Native ETH marker on Ethereum mainnet: the zero address. */
 export declare const __ETH_ADDRESS: `0x${string}`;
 /** Synthetic sentinel the Gondi API uses for native HYPE on HyperEVM. */

package/dist/src/clients/api/index.d.ts

@@ -38,6 +38,10 @@ export declare class Api {
         contractAddress: import("../../generated/graphql").Scalars["Address"];
         tokenId: import("../../generated/graphql").Scalars["BigInt"];
     }>, options?: {} | undefined) => Promise<import("../../generated/graphql").NftIdByContractAddressAndTokenIdQuery>;
+    nftFlaggedByContractAddressAndTokenId: (variables: import("../../generated/graphql").Exact<{
+        contractAddress: import("../../generated/graphql").Scalars["Address"];
+        tokenId: import("../../generated/graphql").Scalars["BigInt"];
+    }>, options?: {} | undefined) => Promise<import("../../generated/graphql").NftFlaggedByContractAddressAndTokenIdQuery>;
     collections: (variables: import("../../generated/graphql").Exact<{
         currency: import("../../generated/graphql").Scalars["Address"];
         collections?: import("../../generated/graphql").InputMaybe<Array<import("../../generated/graphql").Scalars["Int"]> | import("../../generated/graphql").Scalars["Int"]>;

package/dist/src/clients/api/sdk.d.ts

@@ -120,6 +120,10 @@ export declare function getSdkApollo<C>(client: ApolloClient<C>, onStepChange?:
         first?: import("../../generated/graphql").InputMaybe<import("../../generated/graphql").Scalars["Int"]>;
         after?: import("../../generated/graphql").InputMaybe<import("../../generated/graphql").Scalars["String"]>;
     }> | undefined, options?: {} | undefined): Promise<import("../../generated/graphql").ListLoansQuery>;
+    nftFlaggedByContractAddressAndTokenId(variables: import("../../generated/graphql").Exact<{
+        contractAddress: import("../../generated/graphql").Scalars["Address"];
+        tokenId: import("../../generated/graphql").Scalars["BigInt"];
+    }>, options?: {} | undefined): Promise<import("../../generated/graphql").NftFlaggedByContractAddressAndTokenIdQuery>;
     nftIdByContractAddressAndTokenId(variables: import("../../generated/graphql").Exact<{
         contractAddress: import("../../generated/graphql").Scalars["Address"];
         tokenId: import("../../generated/graphql").Scalars["BigInt"];

package/dist/src/clients/contracts/MslV6.d.ts

@@ -9047,6 +9047,13 @@ export declare class MslV6 extends BaseContract<typeof multiSourceLoanAbiV6 | ty
     cancelAllRenegotiations(_: {
         minId: bigint;
     }): Promise<void>;
+    /**
+     * Maps SDK emit arguments to the contract's `LoanExecutionData`.
+     *
+     * @remarks
+     * Without an `expirationTime` the execution data expires `lifetime` seconds from now: a day for
+     * a loan the borrower sends, `BORROWER_SIGNATURE_LIFETIME` when the borrower signs it.
+     */
     private mapEmitLoanToMslEmitLoanArgs;
     emitLoan(emitArgs: EmitLoanArgs): Promise<{
         txHash: `0x${string}`;

package/dist/src/errors.d.ts

@@ -21,3 +21,17 @@ export declare class InterruptedSeaportSendTransactionStepError extends Interrup
         signature: Hash;
     });
 }
+/**
+ * Thrown before a loan is emitted or refinanced against an NFT the GONDI API flags (for example
+ * reported as stolen), or against a wrapper holding one. Lenders' collection offers cannot exclude
+ * a flagged NFT on-chain, so the SDK refuses to borrow against it unless the `Gondi` instance was
+ * created with `skipFlaggedNftCheck`.
+ */
+export declare class FlaggedNftError extends Error {
+    nftCollateralAddress: Address;
+    tokenId: bigint;
+    constructor({ nftCollateralAddress, tokenId, }: {
+        nftCollateralAddress: Address;
+        tokenId: bigint;
+    });
+}

package/dist/src/generated/graphql/index.d.ts

@@ -315,6 +315,8 @@ export type BnplOrderInput = {
     amounts: Array<Scalars['BigInt']>;
     contractAddress: Scalars['Address'];
     creditPurchaseExecution?: InputMaybe<CreditPurchaseExecutionInput>;
+    /** When the borrower's signed loan execution data expires, at most the server's configured lifetime ahead (five minutes by default). Required unless creditPurchaseExecution sets the deadline. */
+    emitExpirationTime?: InputMaybe<Scalars['BigInt']>;
     emitSignature?: InputMaybe<Scalars['Signature']>;
     extraSeaportData?: InputMaybe<Scalars['Hex']>;
     loanDuration: Scalars['BigInt'];
@@ -6360,6 +6362,23 @@ export type ListLoansQuery = {
         }>;
     };
 };
+export type NftFlaggedByContractAddressAndTokenIdQueryVariables = Exact<{
+    contractAddress: Scalars['Address'];
+    tokenId: Scalars['BigInt'];
+}>;
+export type NftFlaggedByContractAddressAndTokenIdQuery = {
+    __typename?: 'Query';
+    nft?: {
+        __typename?: 'NFT';
+        id: string;
+        isFlagged?: boolean | null;
+        wrapsNfts?: Array<{
+            __typename?: 'NFT';
+            id: string;
+            isFlagged?: boolean | null;
+        }> | null;
+    } | null;
+};
 export type NftIdByContractAddressAndTokenIdQueryVariables = Exact<{
     contractAddress: Scalars['Address'];
     tokenId: Scalars['BigInt'];
@@ -10743,6 +10762,7 @@ export declare const CollectionIdBySlugDocument: DocumentNode;
 export declare const CollectionStepsByIdDocument: DocumentNode;
 export declare const ListListingsDocument: DocumentNode;
 export declare const ListLoansDocument: DocumentNode;
+export declare const NftFlaggedByContractAddressAndTokenIdDocument: DocumentNode;
 export declare const NftIdByContractAddressAndTokenIdDocument: DocumentNode;
 export declare const NftIdBySlugTokenIdDocument: DocumentNode;
 export declare const OwnedNftsDocument: DocumentNode;
@@ -10784,6 +10804,7 @@ export declare function getSdk<C, E>(requester: Requester<C, E>): {
     collectionStepsById(variables: CollectionStepsByIdQueryVariables, options?: C): Promise<CollectionStepsByIdQuery>;
     listListings(variables?: ListListingsQueryVariables, options?: C): Promise<ListListingsQuery>;
     listLoans(variables?: ListLoansQueryVariables, options?: C): Promise<ListLoansQuery>;
+    nftFlaggedByContractAddressAndTokenId(variables: NftFlaggedByContractAddressAndTokenIdQueryVariables, options?: C): Promise<NftFlaggedByContractAddressAndTokenIdQuery>;
     nftIdByContractAddressAndTokenId(variables: NftIdByContractAddressAndTokenIdQueryVariables, options?: C): Promise<NftIdByContractAddressAndTokenIdQuery>;
     nftIdBySlugTokenId(variables: NftIdBySlugTokenIdQueryVariables, options?: C): Promise<NftIdBySlugTokenIdQuery>;
     ownedNfts(variables?: OwnedNftsQueryVariables, options?: C): Promise<OwnedNftsQuery>;

package/dist/src/gondi.d.ts

@@ -42,6 +42,14 @@ interface GondiProps {
     publicClient?: GondiPublicClient;
     apiClient?: ApiProps['apiClient'];
     onStepChange?: OnStepChange;
+    /**
+     * Skips the flagged-NFT lookup `emitLoan`, `revokeDelegationsAndEmitLoan`,
+     * `refinanceFromOffers`, `efficientRefinanceFromOffers` and
+     * `crossCurrencyRenegotiation` run before
+     * sending, saving an API call. Only for callers that already keep flagged
+     * NFTs out of those flows themselves, such as the GONDI web app.
+     */
+    skipFlaggedNftCheck?: boolean;
 }
 type Step = {
     type: 'signature';
@@ -65,7 +73,8 @@ export declare class Gondi {
     account: Account;
     bcClient: GondiPublicClient;
     apiClient: Api;
-    constructor({ wallet, publicClient, apiClient, onStepChange }: GondiProps);
+    skipFlaggedNftCheck: boolean;
+    constructor({ wallet, publicClient, apiClient, onStepChange, skipFlaggedNftCheck, }: GondiProps);
     static create(props: GondiProps & {
         onStepChange: OnStepChange;
     }): Gondi;
@@ -875,6 +884,12 @@ export declare class Gondi {
         }>;
     }>;
     offerExecutionFromOffers(offers: OfferFromExecutionOffer[], amounts?: bigint[]): EmitLoanArgs['offerExecution'];
+    /**
+     * Throws `FlaggedNftError` when the API flags the collateral NFT or an NFT it wraps.
+     * An NFT the API does not know throws `NOT_FOUND`, and an API that does not answer
+     * throws its own error: a loan is only sent once the API confirms the NFT is not flagged.
+     */
+    private assertNftNotFlagged;
     emitLoan(args: EmitLoanArgs): Promise<{
         txHash: `0x${string}`;
         waitTxInBlock: () => Promise<{

package/dist/src/index.d.ts

@@ -1,3 +1,4 @@
+export { FlaggedNftError } from './errors';
 export { Gondi } from './gondi';
 export { LoanStatusType, OfferStatus, OffersSortField, Ordering, MarketplaceEnum, TokenStandardType, } from './generated/graphql';
 export type { OnStepChange } from './gondi';