Contracts

Arbitrum Sepolia Contract Addresses

Dederi V2

Contract Name	Contract Address	Description
PortfolioMarginManager	0x3Ab26F78Cf6d285bFFCE2f8AF09345E2F64aD7Be	Portfolio margin settlement layer: liquidation marks, ADL operations, and expiry settlement
DualManager	0x88DDEab8D8a9c93D59e097F14E31eE47E70D218b	Dual-currency financial settlement layer: maturity settlement of dual-currency products
Vault	0xE713691e48d83722d51c493B02e4784687D82de8	Dederi platform vault contract
StandardPMRFQ	0xBE5bd6ECfB5B441af1824987cB737AA414eC0831	Portfolio Margin RFQ Contract - Interaction Portal
DualRFQ	0x7956cC316133CC7bA33CCa5BA59bBfb4DE29fD4c	Dual-Currency Financial RFQ Contract - Interaction Portal
StrategyQuery	0xC101275Db4e7793afb257E1da1E482f5db39e5C7	Interface for strategy queries
Oracle	0xB8E6F1D893FDE4459924f3E3f54ae26aDebd1E50	Dederi oracle contract
Multicall	0xcA11bde05977b3631167028862bE2a173976CA11	System batch execution for ADL and expiry settlement
Future	0x8b548c8f5868da732EAE86B2D05FB0Fc1d0FD9ef	Futures asset (assetType)
Option	0xE0d174345C267Af0950b8e9CCf801A3f292F9890	Options asset (assetType)
Cash	0x7253E420734141D4af99826A840dB6E3aFa0dc0c	Cash asset (assetType)
StrategyStorage	0x280272a7593bf53f2196D8cB3222871C5b84b72E	Strategy NFT Contract

Arbitrum Mainnet Contract Addresses

Contract Name	Contract Address	Description
PortfolioMarginManager	0x7E2E4d07F99f6f6495B8e7f68da087bE5937Ead2	Portfolio margin settlement layer: liquidation marks, ADL operations, and expiry settlement
DualManager	0x5759D9776d16d0FB32582680A589E6138642c466	Dual-currency financial settlement layer: maturity settlement of dual-currency products
Vault	0x686354b37102C1132bBd950BddB5bAF120b125cF	Dederi platform vault contract
StandardPMRFQ	0xFdd38e7cB35AE3A0a8f1c811742501f56f0c1Dbb	Portfolio Margin RFQ Contract - Interaction Portal
DualRFQ	0xaF4596343351c0AdE35fFBE1295AcC541315f2e3	Dual-Currency Financial RFQ Contract - Interaction Portal
StrategyQuery	0x4861805D62c5A1a53E602Dd2946db03b4C9e4e46	Interface for strategy queries
Oracle	0x03Cb664C754489f83BF2f76f6D18De11F76e4DE0	Dederi oracle contract
Multicall	0xcA11bde05977b3631167028862bE2a173976CA11	System batch execution for ADL and expiry settlement
Future	0x676EBAef19613A5F5E028B9d7c7825a771F706a1	Futures asset (assetType)
Option	0xeCBe101e9fEAEa9bD36565A9cdf7b3e1ce9362Fd	Options asset (assetType)
Cash	0x8a89be4749289c815a65a4f227Ae5F859f7E3D9c	Cash asset (assetType)
StrategyStorage	0xb9c719d8d7Bf57D44be640458B1c08d33496A947	Strategy NFT Contract

Vault Contract Interface Description

deposit

Deposit funds into the Dederi vault

• API

  Vault.deposit(address token, address receiver, uint256 amount)

• Parameters

  Name	Type	Description
  token	address	Address of the token being deposited
  receiver	address	Address of the receiver
  amount	uint256	Amount to deposit

getUserNonce

Retrieve the latest snapshot nonce of the user's balance.

• API

Vault.getUserNonce(address user) external view returns (uint256)

- Parameters

| Name | Type    | Description |
| ---- | ------- | ----------- |
| user | address | User address    |

- Return Values

| Name      | Type    | Description |
| --------- | ------- | ----------- |
| userNonce | uint256 | Snapshot nonce   |

### `getUserBalance`

Retrieve the user's balance.

- API

```solidity
Vault.getUserBalance(address user, address token) external view returns (uint256) 

• Parameters

  Name	Type	Description
  user	address	User address
  token	address	Token address

• Return Values

  Name	Type	Description
  userBalance	uint256	User balance

getVaultBalance

Retrieve User Balance

• API

Vault.getVaultBalance(address token)external view returns(uint256)

- Parameters

| Name  | Type    | Description |
| ----- | ------- | ----------- |
| token | address | Token address   |

- Return Values

| Name         | Type    | Description |
| ------------ | ------- | ----------- |
| vaultBalance | uint256 | User balance    |



## Portfolio Margin RFQ Interface Documentation

### `aggregateCall`

The aggregateCall function serves as the primary interaction interface. It allows for aggregated calls by combining oracle price feed actions and RFQ actions. The input should be structured as an array of actions, such as [oracle action1, oracle action2, rfq action]

- API

```solidity
struct Result {
      bool success;
      bytes returnData;
  }
  struct Action {
        address target; // Target contract address
        bool skipRevert; // Whether to skip reverts for this action
        bytes callData; // The msg.data to invoke in the call
    }

// Batch contract calls - triggers transactions to be submitted on-chain
// Note: Oracle transactions must be assembled before making the call
function aggregateCall(Action[] calldata actions) external returns (Result[] memory result);

### `completeTheRFQ`

Spot Quote Execution (Open Position, Add Leg, Close Position)

```solidity
standardPMRFQ.completeTheRFQ(
      StandardPMRFQDataTypes.CompleteTheRFQMakerParams calldata makerParams,
      StandardPMRFQDataTypes.CompleteTheRFQTakerParams calldata takerParams,
      uint256 traceId,
      uint256 deadline,
      bytes calldata signature
  ) external returns (uint256, uint256);


struct CompleteTheRFQMakerParams {
  address taker; // The "taker" here is used to associate the requester of the RFQ (Request for Quote)
  address maker;
  uint256 makerMergeStrategyId;
  uint256 makerNewCashAmount;
  uint256 timestamp; // The current timestamp + expiration timestamp (default is 600 seconds)
  Asset[] makerAssets;
}

struct CompleteTheRFQTakerParams {
  address taker;
  uint256 takerMergeStrategyId;
  uint256 takerNewCashAmount;
}


struct Asset {
  address assetType; // The type of asset; different addresses represent different derivatives, such as the contract address of options or futures
  uint256 assetId; // The asset ID, represented in 256 bits
  int256 units; // The number of units (e.g., contracts); positive indicates long, negative indicates short, with 18 decimal precision
  bytes32 extra; // Additional information; for options and futures, this represents the trade price
}

// Encoding scheme for options
// 160-32-32-32
// bit 0-31: option type (low bits)
// bit 32-63: expiry time
// bit 64-95: strike price
// bit 96-255: underlying asset address (high bits)

// Encoding scheme for futures
// future info (underlying, expiryTime)
// bit 160-32-64
// bit 0-63: reserved bits (low bits)
// bit 64-95: expiry time
// bit 96-255: underlying asset address (high bits)

// Parameters
// - CompleteTheRFQParams: Structure for the parameters required for RFQ (Request for Quote) spot pricing and execution
// - traceId: Request trace ID (a uint256 random number greater than 0)
// - deadline: Expiration time for the execution
// - signature: Maker's offline signature

// Return values
// - return1: The taker's strategy ID after this RFQ
// - return2: The maker's strategy ID after this RFQ


### `cancelQuote`

```Solidity
StandardPMRFQ.cancelQuote(RFQDataTypes.CompleteTheRFQMakerParams calldata params, bytes calldata signature)


struct CompleteTheRFQMakerParams {
  address taker;
  address maker;
  uint256 makerMergeStrategyId;
  uint256 makerNewCashAmount;
  uint256 timestamp;
  Asset[] makerAssets;
}

• params：Quote parameters
• signature：Signature

mergeStrategy

StandardPMRFQ.mergeStrategy(StandardPMRFQDataTypes.MergeStrategyParams calldata params) external returns (uint256);

    struct MergeStrategyParams {
        uint256 traceId; // Unique trace ID for tracking the merge transaction
        uint256 firstStrategyId; // ID of the first strategy being merged 
        uint256 secondStrategyId; // ID of the second strategy being merged
        uint256 cashAmount; // Additional cash to be added to the merged strategy
        uint256 deadline; // Expiration timestamp for completing the merge
    }

• MergeStrategyParams：Structure for merge request parameters
• Return Values：
  • Merged strategy ID, with 0 indicating a complete merge.

splitStrategy

StandardPMRFQ.splitStrategy(StandardPMRFQDataTypes.SplitStrategyParams calldata params)
        external
        returns (uint256, uint256);

    struct SplitStrategyParams {
        uint256 traceId;
        uint256 splitStrategyId;
        uint256 originalCashToNewStrategy; // Cash amount allocated from the original strategy to the new strategy
        uint256 originalStrategyCashAmount; // Total cash allocated to the original strategy from the wallet
        uint256 newStrategyCashAmount; // Total cash allocated to the new strategy from the wallet
        uint256 deadline;
        Asset[] splitAssets;
    }

• SplitStrategyParams：Struct for the request parameters of the splitting strategy.
• Return Values:
  • Strategy1ID: The ID of the original strategy.
  • Strategy2ID: The ID of the newly created strategy after splitting.

addCash

StandardPMRFQ.addCash(uint256 traceId, uint256 strategyId, uint256 cashAmount)

• traceId：The unique identifier for tracking the cash addition transaction.
• strategyId：The ID of the strategy to which the margin (cash) is being added.

reduceCash

StandardPMRFQ.reduceCash(uint256 traceId, uint256 strategyId, uint256 cashAmount)

• traceId：The unique identifier for tracking the cash reduction transaction.
• strategyId：The ID of the strategy from which the margin (cash) is being reduced.
• cashAmount：The amount of cash being reduced from the margin.

transferStrategy

StrategyStorage.approve(StandardPMRFQ address, strategy ID) // Authorize RFQ to transfer permissions for a specific strategy ID
StrategyStorage.getApproved(strategy ID) // Check whether a specific strategy is authorized; if authorized, return the authorized address


StandardPMRFQ.transferStrategy(uint256 strategyId, address newOwner)

Dual Currency Investment RFQ Interface Description

aggregateCall

Aggregate call, the actual interaction interface, requires passing in oracle pricing actions and RFQ actions, e.g., [oracle action1, oracle action2, rfq action].

• API

  struct Result {
        bool success;
        bytes returnData;
    }
    
  struct Action {
        address target; // Target contract
        bool skipRevert; // Whether to skip the revert of a specific action
        bytes callData; // The msg.data of the call
    }
  
  // Batch call contracts - trigger on-chain transactions
  // Note: When calling, oracle transactions must be assembled first
  function aggregateCall(Action[] calldata actions) external returns (Result[] memory result);

completeTheRFQ

  DualRFQ.completeTheRFQ(
      DualRFQDataTypes.CompleteTheRFQMakerParams calldata makerParams,
      DualRFQDataTypes.CompleteTheRFQTakerParams calldata takerParams,
      uint256 traceId,
      uint256 deadline,
      bytes calldata signature
  ) external returns(uint256,uint256);
  
  struct CompleteTheRFQMakerParams {
      address taker;
      address maker;
      Asset makerNewCash; // Same structure as PM RFQ, representing the maker's new margin
      uint256 timestamp; // Maker's quotation time
      Asset makerOptionAsset; // Option derivative
  }

  struct CompleteTheRFQTakerParams {
      address taker;
      Asset takerNewCash; // Taker's new margin
  }
  

• Parameters
  • CompleteTheRFQParams：Parameter structure for dual currency investment RFQ pricing transaction
  • traceId：Request trace ID (a uint256 random number greater than 0)
  • deadline：Execution expiration time
  • signature：Offline signature from the maker
• Return Values
  • return1 ：Strategy ID of the taker after this RFQ
  • return2：Strategy ID of the maker after this RFQ

cancelQuote

DualRFQ.cancelQuote(DualRFQDataTypes.CompleteTheRFQMakerParams calldata makerParams, bytes calldata signature)
        external;


    struct CompleteTheRFQMakerParams {
        address taker;
        address maker;
        Asset makerNewCash; 
        uint256 timestamp;
        Asset makerOptionAsset;
    }

• params：Quotation parameters
• signature：Signature

transferStrategy

StrategyStorage.approve(DualRFQ address, strategy ID) // Authorize RFQ for a specific strategy ID
StrategyStorage.getApproved(strategy ID) // Check whether a specific strategy is authorized; if authorized, return the authorized address

DualRFQ.transferStrategy(uint256 strategyId, address newOwner)

Query Interface Description

getAllStrategyInfo

Retrieve all strategy information.

StrategyQuery.getAllStrategyInfo(uint256 page, uint256 pageSize) external view returns (StrategyInfo[] memory)
    struct StrategyInfo {
        Strategy strategy;
        uint256 strategyId;
        Asset[] availableBalance; // Supports multi-currency balance queries, so Asset is used here
        address owner;
        address owner;
    }
    
    struct Strategy {
        uint256 status; //Strategy status, e.g., 0 - Inactive, 1 - Active, 2 - Liquidated, 3 - ADL
        address strategyManager; //Address that can manage this type of strategy
        Asset[] assets; //Information on owned assets (e.g., derivatives)
    }

• page：Page number to query
• pageSize：Size of each page

getAllStrategyInfoByUser

Retrieve strategy information owned by a specific user.

StrategyQuery.getAllStrategyInfoByUser(address user, uint256 page, uint256 pageSize)
        external
        view
        returns (StrategyInfo[] memory)
        
        
    struct StrategyInfo {
        Strategy strategy;
        uint256 strategyId;
        Asset[] availableBalance; // Supports multi-currency balance queries, so Asset is used here
        address owner;
    }

• user: User's address
• page：Page number to query
• pageSize：Number of items per page

getStrategyBalance

Retrieve the total number of strategies.

StrategyQuery.getStrategyBalance() external view returns (uint256);

getStrategyBalanceByUser

Retrieve the number of strategies owned by a specific user.

StrategyQuery.getStrategyBalanceByUser(address user) external view returns (uint256)

getStrategyInfo

Retrieve details of a specific strategy.

StrategyQuery.getStrategyInfo(uint256 strategyId) external view returns (StrategyInfo memory)

    struct StrategyInfo {
        Strategy strategy;
        uint256 strategyId;
        Asset[] availableBalance; // Supports multi-currency balance queries, so Asset is used here
        address owner;
    }

getOwnerOfStrategy

get strategy owner

StrategyQuery.getOwnerOfStrategy(uint256 strategyId) external view returns (address)

Oracle Interface Description

updateIndexPrices

Upload the index price to the system.

Oracle.updateIndexPrices(PriceParam[] calldata _params)external;

struct PriceParam {
    address token; // Address of the underlying asset contract (e.g., WBTC, WETH)
    uint256 price; // Asset price in 18 decimals
    uint256 timestamp; // when were observations made offchain 
    bytes[] signatures; // signatures 
}

updateIndexTWAPs

Upload the 30-minute Time-Weighted Average Price (TWAP) for an index

Oracle.updateIndexTWAPs(PriceParam[] memory _params)external;

struct PriceParam {
    address token; // Address of the underlying asset contract (e.g., WBTC, WETH)
    uint256 price; // Asset price in 18 decimals 
    uint256 timestamp; // when were observations made offchain 
    bytes[] signatures; // signatures 
}

updateSettleTWAPs

Upload settlement TWAP prices.

Oracle.updateSettleTWAPs(SettleTWAPParam[] memory _params);

struct SettleTWAPParam {
    address token; // Token address
    uint256 settletime; // Settlement time
    uint256 price; // Price in 18 decimals
    uint256 timestamp; // Time of price observation
    bytes[] signatures; // signatures
}

updateABR

Upload ABR data.

Oracle.updateABR(AbrParam calldata _param) external;


struct AbrParam {
    address token; // Asset address
    AbrPriceParam[] prices; // prices
    uint256 timestamp; // when were observations made offchain
    bytes[] signatures; // signatures
}

struct AbrPriceParam {
    uint256 index_price; // Asset price in 18 decimals
    uint256 mark_price; // Asset price in 18 decimals
    uint256 expiration; // expiration
}

updateSVI

Upload SVI (Stochastic Volatility Inspired) data.

Oracle.updateSVI(SVIParam calldata _param) external;

struct SVIParam {
    address token; // Asset address
    SVIItem[] items; // params
    uint256 timestamp; // when were observations made offchain
    bytes[] signatures; // signatures
}

struct SVIItem {
    uint256 expiration;
    int256 SVI_a; // 18 decimals
    uint256 SVI_b; // 18 decimals
    int256 SVI_rho; // 18 decimals
    int256 SVI_m; // 18 decimals
    uint256 SVI_sigma; // sigma in 18 decimals
    uint256 SVI_maturity;
}