Starport

Git Source

Inherits: PausableNonReentrant

State Variables

MAX_FEE_RAKE_BPS

uint88 public constant MAX_FEE_RAKE_BPS = 500;

BPS_DENOMINATOR

uint88 public constant BPS_DENOMINATOR = 10_000;

LOAN_CLOSED_FLAG

uint256 public constant LOAN_CLOSED_FLAG = 0x0;

LOAN_OPEN_FLAG

uint256 public constant LOAN_OPEN_FLAG = 0x1;

_INVALID_LOAN

bytes32 private constant _INVALID_LOAN = 0x045f33d100000000000000000000000000000000000000000000000000000000;

_LOAN_EXISTS

bytes32 private constant _LOAN_EXISTS = 0x14ec57fc00000000000000000000000000000000000000000000000000000000;

SG

Stargate public immutable SG;

chainId

uint256 public immutable chainId;

DEFAULT_CUSTODIAN_CODE_HASH

bytes32 public immutable DEFAULT_CUSTODIAN_CODE_HASH;

CACHED_DOMAIN_SEPARATOR

bytes32 public immutable CACHED_DOMAIN_SEPARATOR;

EIP_DOMAIN

bytes32 public constant EIP_DOMAIN =
    keccak256("EIP712Domain(" "string name," "string version," "uint256 chainId," "address verifyingContract" ")");

VERSION

bytes32 public constant VERSION = keccak256(bytes("0"));

NAME

bytes32 public constant NAME = keccak256(bytes("Starport"));

INTENT_ORIGINATION_TYPEHASH

bytes32 public constant INTENT_ORIGINATION_TYPEHASH = keccak256(
    "Origination(" "address account," "uint256 accountNonce," "bool singleUse," "bytes32 salt," "uint256 deadline,"
    "Caveat[] caveats" ")" "Caveat(" "address enforcer," "bytes data" ")"
);

CAVEAT_TYPEHASH

bytes32 public constant CAVEAT_TYPEHASH = keccak256("Caveat(" "address enforcer," "bytes data" ")");

feeTo

address public feeTo;

defaultFeeRakeBps

uint256 public defaultFeeRakeBps;

feeOverrides

mapping(address => FeeOverride) public feeOverrides;

approvals

mapping(address => mapping(address => ApprovalType)) public approvals;

invalidSalts

mapping(address => mapping(bytes32 => bool)) public invalidSalts;

caveatNonces

mapping(address => uint256) public caveatNonces;

loanState

mapping(uint256 => uint256) public loanState;

Functions

constructor

constructor(address seaport_, Stargate stargate_, address owner_);

domainSeparator

function domainSeparator() public view returns (bytes32);

setOriginateApproval

Sets approval to originate loans without having to check caveats

function setOriginateApproval(address who, ApprovalType approvalType) external;

Parameters

originate

The loan origination method, new loan data is passed in and validated before being issued

function originate(
    AdditionalTransfer[] calldata additionalTransfers,
    CaveatEnforcer.SignedCaveats calldata borrowerCaveat,
    CaveatEnforcer.SignedCaveats calldata lenderCaveat,
    Starport.Loan memory loan
) external payable pausableNonReentrant;

Parameters

refinance

Refinances an existing loan with new pricing data, its the only thing that can be changed

function refinance(
    address lender,
    CaveatEnforcer.SignedCaveats calldata lenderCaveat,
    Starport.Loan memory loan,
    bytes calldata pricingData,
    bytes calldata extraData
) external pausableNonReentrant;

Parameters

settle

Helper to settle a loan guarded to ensure only the loan.custodian can call it

function settle(Loan memory loan) external;

Parameters

incrementCaveatNonce

Increments caveat nonce for sender and emits event

function incrementCaveatNonce() external;

invalidateCaveatSalt

Invalidates a caveat salt

function invalidateCaveatSalt(bytes32 salt) external;

Parameters

setFeeData

Sets the default fee data, only owner can call

function setFeeData(address feeTo_, uint88 defaultFeeRakeBps_) external onlyOwner;

Parameters

setFeeOverride

Sets fee overrides for specific tokens, only owner can call

function setFeeOverride(address token, uint88 bpsOverride, bool enabled) external onlyOwner;

Parameters

applyRefinanceConsiderationToLoan

Refinances an existing loan with new pricing data, its the only thing that can be changed

function applyRefinanceConsiderationToLoan(SpentItem[] memory considerationPayment, SpentItem[] memory carryPayment)
    public
    pure
    returns (SpentItem[] memory newDebt);

Parameters

hashCaveatWithSaltAndNonce

Helper to hash a caveat with a salt and nonce

function hashCaveatWithSaltAndNonce(
    address account,
    bool singleUse,
    bytes32 salt,
    uint256 deadline,
    CaveatEnforcer.Caveat[] calldata caveats
) public view virtual returns (bytes32);

Parameters

Returns

_hashCaveat

Internal view function to derive the EIP-712 hash for a caveat

function _hashCaveat(CaveatEnforcer.Caveat memory caveat) internal pure returns (bytes32);

Parameters

Returns

open

Helper to check if a loan is open

function open(uint256 loanId) public view returns (bool);

Parameters

Returns

closed

Helper to check if a loan is closed

function closed(uint256 loanId) public view returns (bool);

Parameters

Returns

_postRepaymentExecute

Calls postRepayment hook on loan Settlement module

function _postRepaymentExecute(Starport.Loan memory loan, address fulfiller) internal virtual;

Parameters

_callCustody

Internal method to call the custody selector of the custodian if it does not share the same codehash as the default custodian

function _callCustody(Starport.Loan memory loan) internal;

Parameters

_validateAdditionalTransfersRefinance

Internal method to validate additional transfers, only transfer from lender and fullfiller are valid

function _validateAdditionalTransfersRefinance(
    address lender,
    address fulfiller,
    AdditionalTransfer[] memory additionalTransfers
) internal pure;

Parameters

_validateAdditionalTransfersOriginate

Internal method to validate additional transfers, only transfers from borrower, lender, and fullfiller are valid

function _validateAdditionalTransfersOriginate(
    address borrower,
    address lender,
    address fulfiller,
    AdditionalTransfer[] calldata additionalTransfers
) internal pure;

Parameters

_validateAndEnforceCaveats

Internal method to validate and enforce caveats

function _validateAndEnforceCaveats(
    CaveatEnforcer.SignedCaveats calldata signedCaveats,
    address validator,
    AdditionalTransfer[] memory additionalTransfers,
    Starport.Loan memory loan
) internal;

Parameters

_settle

Internal helper to settle a loan

function _settle(Loan memory loan) internal;

Parameters

_feeRake

Sets fee overrides for specific tokens, only owner can call

function _feeRake(SpentItem[] memory debt)
    internal
    view
    returns (SpentItem[] memory feeItems, SpentItem[] memory paymentToBorrower);

Parameters

Returns

acquireTokens

function acquireTokens(SpentItem[] memory items) external;

_issueLoan

Changes loanId status to open for the specified loan

function _issueLoan(Loan memory loan) internal;

Parameters

Events

ApprovalSet

event ApprovalSet(address indexed owner, address indexed spender, uint8 approvalType);

CaveatFilled

event CaveatFilled(address owner, bytes32 hash, bytes32 salt);

CaveatNonceIncremented

event CaveatNonceIncremented(address owner, uint256 newNonce);

CaveatSaltInvalidated

event CaveatSaltInvalidated(address owner, bytes32 salt);

Close

event Close(uint256 loanId);

FeeDataUpdated

event FeeDataUpdated(address feeTo, uint88 defaultFeeRakeBps);

FeeOverrideUpdated

event FeeOverrideUpdated(address token, uint88 overrideBps, bool enabled);

Open

event Open(uint256 loanId, Starport.Loan loan);

Errors

CaveatDeadlineExpired

error CaveatDeadlineExpired();

InvalidFeeRakeBps

error InvalidFeeRakeBps();

InvalidCaveat

error InvalidCaveat();

InvalidCaveatLength

error InvalidCaveatLength();

InvalidCaveatSigner

error InvalidCaveatSigner();

InvalidCustodian

error InvalidCustodian();

InvalidLoan

error InvalidLoan();

InvalidLoanState

error InvalidLoanState();

InvalidPostRepayment

error InvalidPostRepayment();

LoanExists

error LoanExists();

MalformedRefinance

error MalformedRefinance();

NotLoanCustodian

error NotLoanCustodian();

UnauthorizedAdditionalTransferIncluded

error UnauthorizedAdditionalTransferIncluded();

Structs

Terms

struct Terms {
    address status;
    bytes statusData;
    address pricing;
    bytes pricingData;
    address settlement;
    bytes settlementData;
}

Loan

struct Loan {
    uint256 start;
    address custodian;
    address borrower;
    address issuer;
    address originator;
    SpentItem[] collateral;
    SpentItem[] debt;
    Terms terms;
}

FeeOverride

struct FeeOverride {
    bool enabled;
    uint88 bpsOverride;
}

Enums

ApprovalType

enum ApprovalType {
    NOTHING,
    BORROWER,
    LENDER
}