@wormhole-foundation/wormhole-solidity-sdk 1.0.1

package/contracts/constants/ConsistencyLevel.sol

@@ -0,0 +1,9 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.4;
+
+//see https://wormhole.com/docs/products/reference/consistency-levels/
+uint8 constant CONSISTENCY_LEVEL_INSTANT   = 200;
+uint8 constant CONSISTENCY_LEVEL_SAFE      = 201;
+uint8 constant CONSISTENCY_LEVEL_FINALIZED =   1; //alternatively 202 is used
+//see ICustomConsistencyLevel and ConsistencyConfigLib:
+uint8 constant CONSISTENCY_LEVEL_CUSTOM    = 203;

package/contracts/interfaces/ICoreBridge.sol

@@ -0,0 +1,80 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.0;
+
+// ╭─────────────────────────────────────────────────────────────╮
+// │ For verification, consider using `CoreBridgeLib`            │
+// │ For encoding and decoding, consider using `VaaLib`          │
+// │ For replay protection, consider using `ReplayProtectionLib` │
+// ╰─────────────────────────────────────────────────────────────╯
+
+//slimmed down interface of the CoreBridge (aka the Wormhole contract)
+
+struct GuardianSet {
+  address[] keys;
+  uint32 expirationTime;
+}
+
+struct GuardianSignature {
+  bytes32 r;
+  bytes32 s;
+  uint8 v;
+  uint8 guardianIndex;
+}
+
+//VM = Verified Message - legacy struct of the CoreBridge
+//contains fields that are not relevant to the integrator:
+// * version - always 1 regardless
+// * signatures/guardianSetIndex - only the CoreBridge itself cares (for verification)
+// * hash - NOT the VAA hash, but the hash of the hash! see warning at the top of VaaLib.sol!
+//          _finalized_ VAAs should use the unique (emitterChainId, emitterAddress, sequence) triple
+//          for cheaper replay protection, see SequenceReplayProtectionLib
+struct CoreBridgeVM {
+  uint8 version;
+  uint32 timestamp;
+  uint32 nonce;
+  uint16 emitterChainId;
+  bytes32 emitterAddress;
+  uint64 sequence;
+  uint8 consistencyLevel;
+  bytes payload;
+  uint32 guardianSetIndex;
+  GuardianSignature[] signatures;
+  bytes32 hash; //see comment above
+}
+
+interface ICoreBridge {
+  event LogMessagePublished(
+    address indexed sender,
+    uint64 sequence,
+    uint32 nonce,
+    bytes payload,
+    uint8 consistencyLevel
+  );
+
+  // -- publishing --
+
+  function messageFee() external view returns (uint256);
+
+  //Note: This function requires a msg.value equal to the message fee!
+  function publishMessage(
+    uint32 nonce,
+    bytes memory payload,
+    uint8 consistencyLevel
+  ) external payable returns (uint64 sequence);
+
+  // -- verification --
+
+  //consider using `VaaLib` and `CoreBridgeLib` instead to save on gas
+  //  (though at the expense of some code size)
+  function parseAndVerifyVM(
+    bytes calldata encodedVM
+  ) external view returns (CoreBridgeVM memory vm, bool valid, string memory reason);
+
+  // -- getters --
+
+  function chainId() external view returns (uint16);
+  function nextSequence(address emitter) external view returns (uint64);
+
+  function getGuardianSet(uint32 index) external view returns (GuardianSet memory);
+  function getCurrentGuardianSetIndex() external view returns (uint32);
+}

package/contracts/interfaces/ICustomConsistencyLevel.sol

@@ -0,0 +1,12 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.0;
+
+//from https://github.com/wormhole-foundation/wormhole/blob/39081fa2936badf178f8b7e5eb63074d3308bf7d/ethereum/contracts/custom_consistency_level/interfaces/ICustomConsistencyLevel.sol
+interface ICustomConsistencyLevel {
+  //topic0 0xa37f0112e03d41de27266c1680238ff1548c0441ad1e73c82917c000eefdd5ea
+  event ConfigSet(address emitterAddress, bytes32 config);
+
+  function configure(bytes32 config) external;
+
+  function getConfiguration(address emitterAddress) external view returns (bytes32);
+}

package/contracts/interfaces/IDeliveryProvider.sol

@@ -0,0 +1,84 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.0;
+
+interface IDeliveryProvider {
+
+  /**
+   * @notice This function returns
+   *
+   * 1) nativePriceQuote: the price of a delivery (by this delivery provider) to chain
+   * 'targetChain', giving the user's contract 'receiverValue' target chain wei and performing the
+   * relay with the execution parameters (e.g. the gas limit) specified in 'encodedExecutionParameters'
+   *
+   * 2) encodedExecutionInfo: information relating to how this delivery provider
+   * will perform such a delivery (e.g. the gas limit, and the amount it will refund per gas unused)
+   *
+   * encodedExecutionParameters and encodedExecutionInfo both are encodings of versioned structs -
+   * version EVM_V1 of ExecutionParameters specifies the gas limit,
+   * and version EVM_V1 of ExecutionInfo specifies the gas limit and the amount that this delivery provider
+   * will refund per unit of gas unused
+   */
+  function quoteDeliveryPrice(
+    uint16 targetChain,
+    uint256 receiverValue,
+    bytes memory encodedExecutionParams
+  ) external view returns (uint256 nativePriceQuote, bytes memory encodedExecutionInfo);
+
+  /**
+   * @notice This function returns the amount of extra 'receiverValue' (msg.value on the target chain)
+   * that will be sent to your contract, if you specify 'currentChainAmount' in the
+   * 'paymentForExtraReceiverValue' field on 'send'
+   */
+  function quoteAssetConversion(
+    uint16 targetChain,
+    uint256 currentChainAmount
+  ) external view returns (uint256 targetChainAmount);
+
+  /**
+   * @notice This function should return a payable address on this (source) chain where all awards
+   *     should be sent for the relay provider.
+   */
+  function getRewardAddress() external view returns (address payable rewardAddress);
+
+  /**
+   * @notice This function determines whether a relay provider supports deliveries to a given chain
+   *     or not.
+   *
+   * @param targetChain - The chain which is being delivered to.
+   */
+  function isChainSupported(uint16 targetChain) external view returns (bool supported);
+
+  /**
+   * @notice This function determines whether a relay provider supports the given keyType.
+   *
+   * Note: 0-127 are reserved for standardized keyTypes and 128-255 are allowed to be custom per DeliveryProvider
+   *       Practically this means that 0-127 must mean the same thing for all DeliveryProviders,
+   *       while x within 128-255 may have different meanings between DeliveryProviders
+   *       (e.g. 130 for provider A means pyth price quotes while 130 for provider B means tweets,
+   *       but 8 must mean the same for both)
+   *
+   * @param keyType - The keyType within MessageKey that specifies what the encodedKey within a MessageKey means
+   */
+  function isMessageKeyTypeSupported(uint8 keyType) external view returns (bool supported);
+
+  /**
+   * @notice This function returns a bitmap encoding all the keyTypes this provider supports
+   *
+   * Note: 0-127 are reserved for standardized keyTypes and 128-255 are allowed to be custom per DeliveryProvider
+   *       Practically this means that 0-127 must mean the same thing for all DeliveryProviders,
+   *       while x within 128-255 may have different meanings between DeliveryProviders
+   *       (e.g. 130 for provider A means pyth price quotes while 130 for provider B means tweets,
+   *       but 8 must mean the same for both)
+   */
+  function getSupportedKeys() external view returns (uint256 bitmap);
+
+  /**
+   * @notice If a DeliveryProvider supports a given chain, this function should provide the contract
+   *      address (in wormhole format) of the relay provider on that chain.
+   *
+   * @param targetChain - The chain which is being delivered to.
+   */
+  function getTargetChainAddress(
+    uint16 targetChain
+  ) external view returns (bytes32 deliveryProviderAddress);
+}

package/contracts/interfaces/IExecutor.sol

@@ -0,0 +1,32 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.0;
+
+//see https://github.com/wormholelabs-xyz/example-messaging-executor/blob/ec5daea3c03f8860a62c23e28db5c6dc8771a9ce/evm/src/interfaces/IExecutor.sol
+
+event RequestForExecution(
+  address indexed quoterAddress,
+  uint256 amtPaid,
+  uint16  dstChain,
+  bytes32 dstAddr,
+  address refundAddr,
+  bytes   signedQuote,
+  bytes   requestBytes,
+  bytes   relayInstructions
+);
+
+interface IExecutor {
+  function requestExecution(
+    uint16  dstChain,
+    bytes32 dstAddr,
+    address refundAddr,
+    bytes calldata signedQuote,
+    bytes calldata requestBytes,
+    bytes calldata relayInstructions
+  ) external payable;
+}
+
+//from https://github.com/wormholelabs-xyz/example-messaging-executor/blob/ec5daea3c03f8860a62c23e28db5c6dc8771a9ce/evm/src/interfaces/IVaaV1Receiver.sol
+//required interface for receiving MultiSig (=V1) VAAs from the executor
+interface IVaaV1Receiver {
+  function executeVAAv1(bytes memory multiSigVaa) external payable;
+}

package/contracts/interfaces/ITokenBridge.sol

@@ -0,0 +1,81 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.0;
+
+//slimmed down interface of TokenBridge (only integrator relevant functions)
+
+interface ITokenBridge {
+  event TransferRedeemed(
+    uint16 indexed emitterChainId,
+    bytes32 indexed emitterAddress,
+    uint64 indexed sequence
+  );
+
+  // -- transfer functions --
+
+  function wrapAndTransferETH(
+    uint16 recipientChain,
+    bytes32 recipient,
+    uint256 arbiterFee, //no built-in relayer -> unused, always set to 0
+    uint32 nonce
+  ) external payable returns (uint64 sequence);
+
+  function transferTokens(
+    address token,
+    uint256 amount,
+    uint16 recipientChain,
+    bytes32 recipient,
+    uint256 arbiterFee, //no built-in relayer -> unused, always set to 0
+    uint32 nonce
+  ) external payable returns (uint64 sequence);
+
+  function wrapAndTransferETHWithPayload(
+    uint16 recipientChain,
+    bytes32 recipient,
+    uint32 nonce,
+    bytes calldata payload
+  ) external payable returns (uint64 sequence);
+
+  function transferTokensWithPayload(
+    address token,
+    uint256 amount,
+    uint16 recipientChain,
+    bytes32 recipient,
+    uint32 nonce,
+    bytes calldata payload
+  ) external payable returns (uint64 sequence);
+
+  // -- completeTransfer functions --
+
+  function completeTransfer(bytes calldata encodedVaa) external;
+  function completeTransferAndUnwrapETH(bytes calldata encodedVaa) external;
+
+  //transfers tokens to the recipient (must be msg.sender) and returns the payload of the transfer
+  //use libraries/TokenBridgeMessages.sol to decode e.g. emitter chain and fromAddress if required
+  function completeTransferWithPayload(bytes calldata encodedVaa) external returns (bytes memory);
+  function completeTransferAndUnwrapETHWithPayload(
+    bytes calldata encodedVaa
+  ) external returns (bytes memory);
+
+  // -- token attestation functions --
+
+  function attestToken(address token, uint32 nonce) external payable returns (uint64 sequence);
+  function createWrapped(bytes calldata encodedVaa) external returns (address token);
+  function updateWrapped(bytes calldata encodedVaa) external returns (address token);
+
+  // -- view functions --
+
+  //convenience function that wraps the core bridge's chainId()
+  function chainId() external view returns (uint16);
+  //returns address of the core bridge
+  function wormhole() external view returns (address);
+  //returns universal address of peer contracts on other chains
+  function bridgeContracts(uint16 chainId) external view returns (bytes32);
+  //underlying implementation of the beacon
+  function tokenImplementation() external view returns (address);
+  //returns address of the canonical wrapped native token
+  function WETH() external view returns (address);
+
+  function isTransferCompleted(bytes32 hash) external view returns (bool);
+  function isWrappedAsset(address token) external view returns (bool);
+  function wrappedAsset(uint16 tokenChainId, bytes32 tokenAddress) external view returns (address);
+}