USDC

CCTP ist die bevorzugte Methode, um USDC nativ auf der Hyperliquid L1 zu prägen. Die von Circle veröffentlichten Contracts und Abläufe finden Sie unter https://github.com/circlefin/hyperevm-circle-contracts.

Veraltete Bridge

CCTP unterstützt mehr Chains und mehr Funktionen. Die ältere Bridge ist veraltet.

Vertrag: https://arbiscan.io/address/0x2df1c51e09aecf9cacb7bc98cb1742757f163df7

Quelle: https://github.com/hyperliquid-dex/contracts/blob/master/Bridge2.sol

Einzahlung

Der Einzahlungsablauf der Bridge ist einfach. Der Nutzer sendet natives USDC an die Bridge, und es wird dem Konto, von dem es gesendet wurde, in weniger als 1 Minute gutgeschrieben. Der Mindesteinzahlungsbetrag beträgt 5 USDC. Wenn Sie einen geringeren Betrag senden, wird dieser nicht gutgeschrieben und ist dauerhaft verloren.

Auszahlung

Der Auszahlungsablauf erfordert lediglich eine Signatur der Nutzer-Wallet auf Hyperliquid und keine Arbitrum-Transaktion. Die Auszahlung von Arbitrum wird vollständig von den Validatoren abgewickelt, und die Guthaben treffen innerhalb von 3-4 Minuten in der Nutzer-Wallet ein. Dieser Payload für signTypedData lautet

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
#[serde(deny_unknown_fields)]
pub(crate) struct WithdrawAction3 {
    pub(crate) signature_chain_id: U256,
    pub(crate) hyperliquid_chain: Chain,
    pub(crate) destination: String,
    pub(crate) amount: String,
    pub(crate) time: u64,
}

impl Eip712 for WithdrawAction3 {
    type Error = Eip712Error;

    fn domain(&self) -> StdResult<EIP712Domain, Self::Error> {
        Ok(eip_712_domain(self.signature_chain_id))
    }

    fn type_hash() -> StdResult<[u8; 32], Self::Error> {
        Ok(eip712::make_type_hash(
            format!("{HYPERLIQUID_EIP_PREFIX}Withdraw"),
            &[
                ("hyperliquidChain".to_string(), ParamType::String),
                ("destination".to_string(), ParamType::String),
                ("amount".to_string(), ParamType::String),
                ("time".to_string(), ParamType::Uint(64)),
            ],
        ))
    }

    fn struct_hash(&self) -> StdResult<[u8; 32], Self::Error> {
        let Self { signature_chain_id: _, hyperliquid_chain, destination, amount, time } = self;
        let items = vec![
            ethers::abi::Token::Uint(Self::type_hash()?.into()),
            encode_eip712_type(hyperliquid_chain.to_string().into_token()),
            encode_eip712_type(destination.clone().into_token()),
            encode_eip712_type(amount.clone().into_token()),
            encode_eip712_type(time.into_token()),
        ];
        Ok(keccak256(encode(&items)))
    }
}

Beispiel einer signierten Hyperliquid-Action:

{
    "action": {
        "type": "withdraw3",
        "signatureChainId": "0xa4b1",
        "hyperliquidChain": "Mainnet" or "Testnet" 
        "destination": "0x000....0",
        "amount": "12.3",
        "time": 1698693262
    },
    "nonce": 1698693262 // IMPORTANT: this must match "time",
    "signature": {"r": ..., "s": ..., "v": ... } // signedTypedData output based on Eip712 implementation above. See python sdk for equivalent python code
}

Einzahlung mit Permit

Die Bridge unterstützt Einzahlungen im Auftrag eines anderen Nutzers über die batchedDepositWithPermitFunktion. Beispielcode dafür, wie der Nutzer das PermitPayload signieren kann

const payload: PermitPayload = {
  owner, // The address of the user with funds they want to deposit
  spender, // The address of the bridge 0x2df1c51e09aecf9cacb7bc98cb1742757f163df7 on mainnet and 0x08cfc1B6b2dCF36A1480b99353A354AA8AC56f89 on testnet
  value,
  nonce,
  deadline,
};

const isMainnet = true;

const domain = {
  name: isMainnet ? "USD Coin" : "USDC2",
  version: isMainnet ? "2" : "1",
  chainId: isMainnet ? 42161 : 421614,
  verifyingContract: isMainnet ? "0xaf88d065e77c8cC2239327C5EDb3A432268e5831" : "0x1baAbB04529D43a73232B713C0FE471f7c7334d5",
};

const permitTypes = {
  Permit: [
    { name: "owner", type: "address" },
    { name: "spender", type: "address" },
    { name: "value", type: "uint256" },
    { name: "nonce", type: "uint256" },
    { name: "deadline", type: "uint256" },
  ],
};

const dataToSign = {
  domain,
  types: permitTypes,
  primaryType: "Permit",
  message: payload,
} as const;

const data = await walletClient.signTypedData(dataToSign);
const signature = splitSig(data);