('#preview')!.innerHTML = `
+ Raw Payload
+ ${thePayload}
+
+ TNLS Payload
+ ${ciphertext.toString('base64')}
+
+ Payload Hash
+ ${payloadHash}
+
+
Payload Signature
+ ${payloadSignature}
+
+
Other Info
+
+
+ Public key used during encryption: ${userPublicKey}
+ Nonce used during encryption: ${nonce}
+
+
+
+ Transaction Parameters
+ Tx Hash: ${txHash}
+ Gateway Address (to check the postExecution callback) ${publicClientAddress}
+ ${JSON.stringify(tx_params)}
+ `
+ })
+}
+// Tx Hash: ${txHash}
+//Gateway Address (to check the postExecution callback) ${publicClientAddress}
+//${JSON.stringify(tx_params)}
\ No newline at end of file
diff --git a/TNLS-Clients/VRFDemo/src/vite-env.d.ts b/TNLS-Clients/VRFDemo/src/vite-env.d.ts
new file mode 100644
index 0000000..11f02fe
--- /dev/null
+++ b/TNLS-Clients/VRFDemo/src/vite-env.d.ts
@@ -0,0 +1 @@
+///
diff --git a/TNLS-Clients/VRFDemo/tsconfig.json b/TNLS-Clients/VRFDemo/tsconfig.json
new file mode 100644
index 0000000..c82b46b
--- /dev/null
+++ b/TNLS-Clients/VRFDemo/tsconfig.json
@@ -0,0 +1,20 @@
+{
+ "compilerOptions": {
+ "target": "ESNext",
+ "useDefineForClassFields": true,
+ "module": "ESNext",
+ "lib": ["ESNext", "DOM"],
+ "moduleResolution": "Node",
+ "strict": true,
+ "sourceMap": true,
+ "resolveJsonModule": true,
+ "isolatedModules": true,
+ "esModuleInterop": true,
+ "noEmit": true,
+ "noUnusedLocals": false,
+ "noUnusedParameters": false,
+ "noImplicitReturns": true,
+ "skipLibCheck": true
+ },
+ "include": ["src"]
+}
diff --git a/TNLS-Clients/VRFDemo/vite.config.ts b/TNLS-Clients/VRFDemo/vite.config.ts
new file mode 100644
index 0000000..13298e7
--- /dev/null
+++ b/TNLS-Clients/VRFDemo/vite.config.ts
@@ -0,0 +1,13 @@
+import { fileURLToPath, URL } from "node:url";
+
+import { defineConfig } from "vite";
+
+// https://vitejs.dev/config/
+export default defineConfig({
+ plugins: [],
+ resolve: {
+ alias: {
+ "@": fileURLToPath(new URL("./src", import.meta.url)),
+ },
+ },
+});
diff --git a/TNLS-Clients/payload-encryption/package-lock.json b/TNLS-Clients/payload-encryption/package-lock.json
index baf7d57..fb09a65 100644
--- a/TNLS-Clients/payload-encryption/package-lock.json
+++ b/TNLS-Clients/payload-encryption/package-lock.json
@@ -1059,7 +1059,8 @@
},
"node_modules/elliptic": {
"version": "6.5.4",
- "license": "MIT",
+ "resolved": "https://registry.npmjs.org/elliptic/-/elliptic-6.5.4.tgz",
+ "integrity": "sha512-iLhC6ULemrljPZb+QutR5TQGB+pdW6KGD5RSegS+8sorOZT+rdQFbsQFJgvN3eRqNALqJer4oQ16YvJHlU8hzQ==",
"dependencies": {
"bn.js": "^4.11.9",
"brorand": "^1.1.0",
@@ -2034,7 +2035,8 @@
},
"node_modules/secure-random": {
"version": "1.1.2",
- "license": "MIT"
+ "resolved": "https://registry.npmjs.org/secure-random/-/secure-random-1.1.2.tgz",
+ "integrity": "sha512-H2bdSKERKdBV1SwoqYm6C0y+9EA94v6SUBOWO8kDndc4NoUih7Dv6Tsgma7zO1lv27wIvjlD0ZpMQk7um5dheQ=="
},
"node_modules/semver": {
"version": "7.5.4",
diff --git a/TNLS-Clients/payload-encryption/src/wasm/encrypt_payload_bg.wasm.gz b/TNLS-Clients/payload-encryption/src/wasm/encrypt_payload_bg.wasm.gz
deleted file mode 100644
index 1b5e9f4..0000000
Binary files a/TNLS-Clients/payload-encryption/src/wasm/encrypt_payload_bg.wasm.gz and /dev/null differ
diff --git a/TNLS-Gateways/public-gateway/lib/openzeppelin-contracts b/TNLS-Gateways/public-gateway/lib/openzeppelin-contracts
new file mode 160000
index 0000000..01ef448
--- /dev/null
+++ b/TNLS-Gateways/public-gateway/lib/openzeppelin-contracts
@@ -0,0 +1 @@
+Subproject commit 01ef448981be9d20ca85f2faf6ebdf591ce409f3
diff --git a/TNLS-Gateways/public-gateway/script/DeployScript.s.sol b/TNLS-Gateways/public-gateway/script/DeployScript.s.sol
index 939ce9a..02904f2 100644
--- a/TNLS-Gateways/public-gateway/script/DeployScript.s.sol
+++ b/TNLS-Gateways/public-gateway/script/DeployScript.s.sol
@@ -7,17 +7,23 @@ import "forge-std/console2.sol";
import "forge-std/Script.sol";
import {Gateway} from "../src/Gateway.sol";
import {RandomnessReciever} from "../src/RandomnessReciever.sol";
+import "@openzeppelin/contracts/proxy/transparent/ProxyAdmin.sol";
+import "@openzeppelin/contracts/proxy/transparent/TransparentUpgradeableProxy.sol";
+
contract DeployScript is Script {
function setUp() public {}
- Gateway gatewayAddress;
+ address deployer;
+ ProxyAdmin proxyAdmin;
+ Gateway gatewayLogic;
+ TransparentUpgradeableProxy gatewayProxy;
RandomnessReciever randomnessAddress;
-
+
uint256 privKey = vm.envUint("ETH_PRIVATE_KEY");
- address deployer = vm.rememberKey(privKey);
- /// @notice Get the encoded hash of the inputs for signing
+
+ /// @notice Get the encoded hash of the inputs for signing
/// @param _routeInput Route name
/// @param _verificationAddressInput Address corresponding to the route
function getRouteHash(string memory _routeInput, address _verificationAddressInput) public pure returns (bytes32) {
@@ -35,24 +41,43 @@ contract DeployScript is Script {
}
function run() public {
+ deployer = vm.rememberKey(privKey);
vm.startBroadcast();
- gatewayAddress = new Gateway();
- randomnessAddress = new RandomnessReciever();
+ // Deploy ProxyAdmin
+ proxyAdmin = new ProxyAdmin(msg.sender);
+
+ // Deploy Gateway Logic Contract
+ gatewayLogic = new Gateway();
- console2.logAddress(address(gatewayAddress));
+ // Prepare initializer data for Gateway
+ bytes memory initializerData = abi.encodeWithSelector(
+ Gateway.initialize.selector
+ );
+
+ // Deploy TransparentUpgradeableProxy
+ gatewayProxy = new TransparentUpgradeableProxy(
+ address(gatewayLogic),
+ address(proxyAdmin),
+ initializerData
+ );
+
+ // Cast the proxy address to the Gateway interface
+ Gateway gateway = Gateway(address(gatewayProxy));
+
+ // Continue with your existing setup, but replace `gatewayAddress` with `gateway`
+ randomnessAddress = new RandomnessReciever();
+ console2.logAddress(address(gateway));
console2.logAddress(deployer);
- randomnessAddress.setGatewayAddress(address(gatewayAddress));
+ randomnessAddress.setGatewayAddress(address(gateway));
+
// Initialize master verification Address
- gatewayAddress.setMasterVerificationAddress(deployer);
- gatewayAddress.setContractAddressAndCodeHash("secret1u3zsgg680f0fmjv7w6qkhpe6sh78wngzevvlvd",
- "866d57146b2d9cccde295b57d84f22995568ffb5dc31a795e73f351bbfb19dfb");
- address verificationAddress = 0xBC0951b2f849020027921e7286aE134C8e159203;
- gatewayAddress.setChainidentifier("ethereum");
+ gateway.setMasterVerificationAddress(deployer); // Replace gatewayAddress with gateway
+ address verificationAddress = 0x09362bF5bbA88948f8B9fCDbB5B56C8CdD2403ad;
/// ------ Update Routes Param Setup ------- ///
- string memory route = "secret";
+ string memory route = "secret-4";
//address verificationAddress = vm.envAddress("SECRET_GATEWAY_ETH_ADDRESS");
// Update the route with with masterVerificationKey signature
@@ -62,8 +87,8 @@ contract DeployScript is Script {
(uint8 v, bytes32 r, bytes32 s) = vm.sign(privKey, ethSignedMessageHash);
bytes memory sig = abi.encodePacked(r, s, v);
- gatewayAddress.updateRoute(route, verificationAddress, sig);
+ gateway.updateRoute(route, verificationAddress, sig);
vm.stopBroadcast();
}
-}
+}
\ No newline at end of file
diff --git a/TNLS-Gateways/public-gateway/src/Gateway.sol b/TNLS-Gateways/public-gateway/src/Gateway.sol
index 8da7ed3..ed03b11 100644
--- a/TNLS-Gateways/public-gateway/src/Gateway.sol
+++ b/TNLS-Gateways/public-gateway/src/Gateway.sol
@@ -1,8 +1,26 @@
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.23;
-contract Gateway {
+import "@openzeppelin/contracts/proxy/utils/Initializable.sol";
+import "@openzeppelin/contracts/proxy/transparent/TransparentUpgradeableProxy.sol";
+import "@openzeppelin/contracts/proxy/transparent/ProxyAdmin.sol";
+
+ /*//////////////////////////////////////////////////////////////
+ Gateway Proxy
+ //////////////////////////////////////////////////////////////*/
+contract GatewayProxy is TransparentUpgradeableProxy {
+ constructor(address _logic, address admin_, bytes memory _data) TransparentUpgradeableProxy(_logic, admin_, _data) {}
+}
+
+ /*//////////////////////////////////////////////////////////////
+ Secret VRF Interface
+ //////////////////////////////////////////////////////////////*/
+interface IRandomness {
+ function fulfillRandomWords(uint256 requestId, uint256[] calldata randomWords) external;
+}
+
+contract Gateway is Initializable {
/*//////////////////////////////////////////////////////////////
Structs
//////////////////////////////////////////////////////////////*/
@@ -22,6 +40,13 @@ contract Gateway {
bytes payload_signature;
}
+ struct VRFSecretContract {
+ bytes32 contract_address_1;
+ bytes13 contract_address_2;
+ bytes32 contract_code_hash_1;
+ bytes32 contract_code_hash_2;
+ }
+
struct PostExecutionInfo {
bytes32 payload_hash;
bytes32 result_hash;
@@ -34,6 +59,21 @@ contract Gateway {
bytes result;
}
+ /*//////////////////////////////////////////////////////////////
+ State Variables
+ //////////////////////////////////////////////////////////////*/
+
+ address public owner;
+ address public masterVerificationAddress;
+ uint256 public taskId;
+
+ /// @dev Task ID ====> ReducedTask
+ mapping(uint256 => ReducedTask) public tasks;
+
+ /// @dev mapping of chain name string to the verification address
+ mapping(string => address) public route;
+
+
/*//////////////////////////////////////////////////////////////
Errors
//////////////////////////////////////////////////////////////*/
@@ -66,8 +106,11 @@ contract Gateway {
Helpers
//////////////////////////////////////////////////////////////*/
- /// @notice Splitting signature util for recovery
- /// @param _sig The signature
+ /// @notice Splits a signature into its r, s, and v components
+ /// @param _sig The signature to split
+ /// @return r The r component of the signature
+ /// @return s The s component of the signature
+ /// @return v The recovery byte of the signature
function splitSignature(bytes memory _sig) private pure returns (bytes32 r, bytes32 s, uint8 v) {
require(_sig.length == 65, "invalid signature length");
@@ -81,19 +124,20 @@ contract Gateway {
}
}
- /// @notice Recover the signer from message hash with a valid recovery ID
- /// @param _signedMessageHash the signed message hash
- /// @param _signature The signature that needs to be verified
+ /// @notice Recovers the signer address from a message hash and a signature
+ /// @param _signedMessageHash The hash of the signed message
+ /// @param _signature The signature
+ /// @return The address of the signer
function recoverSigner(bytes32 _signedMessageHash, bytes memory _signature) private pure returns (address) {
(bytes32 r, bytes32 s, uint8 v) = splitSignature(_signature);
-
return ecrecover(_signedMessageHash, v, r, s);
}
- /// @notice Get the encoded hash of the inputs for signing
- /// @param _routeInput Route name
- /// @param _verificationAddressInput Address corresponding to the route
+ /// @notice Calculates the keccak256 hash of the route name and verification address
+ /// @param _routeInput The route name
+ /// @param _verificationAddressInput The verification address
+ /// @return The calculated hash
function getRouteHash(string calldata _routeInput, address _verificationAddressInput) private pure returns (bytes32) {
return keccak256(abi.encode(_routeInput, _verificationAddressInput));
}
@@ -102,6 +146,77 @@ contract Gateway {
return bytes31(data & 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF00);
}
+ function encodeBase64(bytes memory data) private pure returns (string memory) {
+ if (data.length == 0) return "";
+ string memory table = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+ string memory result = new string(4 * ((data.length + 2) / 3));
+ /// @solidity memory-safe-assembly
+ assembly {
+ let tablePtr := add(table, 1)
+ let resultPtr := add(result, 32)
+ for {
+ let dataPtr := data
+ let endPtr := add(data, mload(data))
+ } lt(dataPtr, endPtr) {
+ } {
+ dataPtr := add(dataPtr, 3)
+ let input := mload(dataPtr)
+ mstore8(resultPtr, mload(add(tablePtr, and(shr(18, input), 0x3F))))
+ resultPtr := add(resultPtr, 1)
+ mstore8(resultPtr, mload(add(tablePtr, and(shr(12, input), 0x3F))))
+ resultPtr := add(resultPtr, 1)
+ mstore8(resultPtr, mload(add(tablePtr, and(shr(6, input), 0x3F))))
+ resultPtr := add(resultPtr, 1)
+ mstore8(resultPtr, mload(add(tablePtr, and(input, 0x3F))))
+ resultPtr := add(resultPtr, 1)
+ }
+ switch mod(mload(data), 3)
+ case 1 {
+ mstore8(sub(resultPtr, 1), 0x3d)
+ mstore8(sub(resultPtr, 2), 0x3d)
+ }
+ case 2 {
+ mstore8(sub(resultPtr, 1), 0x3d)
+ }
+ }
+ return result;
+ }
+
+ function uint256toString(uint256 value) private pure returns (string memory ptr) {
+ assembly {
+ ptr := add(mload(0x40), 128)
+ mstore(0x40, ptr)
+ let end := ptr
+ for {
+ let temp := value
+ ptr := sub(ptr, 1)
+ mstore8(ptr, add(48, mod(temp, 10)))
+ temp := div(temp, 10)
+ } temp {
+ temp := div(temp, 10)
+ } {
+ ptr := sub(ptr, 1)
+ mstore8(ptr, add(48, mod(temp, 10)))
+ }
+ let length := sub(end, ptr)
+ ptr := sub(ptr, 32)
+ mstore(ptr, length)
+ }
+ }
+
+ function bytesToUint256Array(bytes memory data) public pure returns (uint256[] memory) {
+ require(data.length % 32 == 0, "Data length must be a multiple of 32 bytes");
+
+ uint256[] memory uintArray;
+ assembly {
+ // Cast the bytes array to a uint256[] array by setting the appropriate length
+ uintArray := data
+ mstore(uintArray, div(mload(data), 32))
+ }
+ return uintArray;
+ }
+
+
/*//////////////////////////////////////////////////////////////
Events
//////////////////////////////////////////////////////////////*/
@@ -121,58 +236,46 @@ contract Gateway {
event ComputedResult(uint256 taskId, bytes result);
/*//////////////////////////////////////////////////////////////
- Constructor
+ Modifiers
//////////////////////////////////////////////////////////////*/
- address private immutable owner;
- string private chainIdentifier;
- string private routing_info;
- string private routing_code_hash;
-
- constructor() {
- owner = msg.sender;
- }
-
modifier onlyOwner() {
require(msg.sender == owner, "UNAUTHORIZED");
_;
}
+ /*//////////////////////////////////////////////////////////////
+ Initializer
+ //////////////////////////////////////////////////////////////*/
+
+ /// @notice Replaces the constructor for upgradeable contracts
+ function initialize() public initializer {
+ owner = msg.sender;
+ taskId = 1;
+ }
+
/*//////////////////////////////////////////////////////////////
Initialization
//////////////////////////////////////////////////////////////*/
- address private masterVerificationAddress;
-
/// @notice Initialize the verification address
/// @param _masterVerificationAddress The input address
function setMasterVerificationAddress(address _masterVerificationAddress) external onlyOwner {
masterVerificationAddress = _masterVerificationAddress;
}
- function setContractAddressAndCodeHash(string calldata _contractAddress, string calldata _codeHash) external onlyOwner {
- routing_info = _contractAddress;
- routing_code_hash = _codeHash;
- }
-
- function setChainidentifier(string calldata _chainIdentifier) external onlyOwner {
- chainIdentifier = _chainIdentifier;
- }
-
/*//////////////////////////////////////////////////////////////
Update Routes
//////////////////////////////////////////////////////////////*/
- /// @dev mapping of chain name string to the verification address
- mapping(string => address) private route;
-
/// @notice Updating the route
/// @param _route Route name
/// @param _verificationAddress Address corresponding to the route
/// @param _signature Signed hashed inputs(_route + _verificationAddress)
+
function updateRoute(string calldata _route, address _verificationAddress, bytes calldata _signature) external onlyOwner {
bytes32 routeHash = getRouteHash(_route, _verificationAddress);
- bytes32 ethSignedMessageHash = keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", routeHash));
+ bytes32 ethSignedMessageHash = keccak256(bytes.concat("\x19Ethereum Signed Message:\n32", routeHash));
if (recoverSigner(ethSignedMessageHash, _signature) != masterVerificationAddress) {
revert InvalidSignature();
@@ -185,27 +288,26 @@ contract Gateway {
Pre Execution
//////////////////////////////////////////////////////////////*/
- uint256 private taskId = 1;
-
- /// @dev Task ID ====> Task
- mapping(uint256 => ReducedTask) private tasks;
-
- /// @notice Send
- /// @param _userAddress User address
- /// @param _sourceNetwork Source network of msg
- /// @param _routingInfo Routing info for computation
- /// @param _payloadHash Payload hash
- /// @param _info ExecutionInfo struct
+ /// @notice Creates a new task with provided execution info
+ /// @param _payloadHash Hash of the payload
+ /// @param _userAddress Address of the user
+ /// @param _routingInfo Routing information
+ /// @param _info Execution information
function send(
bytes32 _payloadHash,
address _userAddress,
- string calldata _sourceNetwork,
string calldata _routingInfo,
ExecutionInfo calldata _info)
- external {
+ external payable {
- // Payload hash signature verification
+ // Payload hash verification
+
+ if (keccak256(bytes.concat("\x19Ethereum Signed Message:\n32", keccak256(_info.payload))) != _payloadHash) {
+ revert InvalidPayloadHash();
+ }
+
+ // Payload signature verification
if (recoverSigner(_payloadHash, _info.payload_signature) != _userAddress) {
revert InvalidSignature();
@@ -216,7 +318,7 @@ contract Gateway {
emit logNewTask(
taskId,
- _sourceNetwork,
+ uint256toString(block.chainid),
_userAddress,
_routingInfo,
_payloadHash,
@@ -226,52 +328,62 @@ contract Gateway {
taskId++;
}
- function requestRandomWords(
+ /// @notice Requests random words for VRF
+ /// @param _numWords The number of random words requested
+ /// @param _callbackGasLimit The gas limit for the callback
+ /// @return requestId The request ID for the random words
+
+ function requestRandomness(
uint32 _numWords,
uint32 _callbackGasLimit
) external payable returns (uint256 requestId) {
- require(_numWords <= 50, "Too many words requested");
+ require(_numWords <= 2000, "Too many words requested");
- string memory callback_address = Encoders.encodeBase64(abi.encodePacked(msg.sender));
+ string memory callback_address = encodeBase64(bytes.concat(bytes20(msg.sender)));
- bytes memory payload = abi.encodePacked(
+ //use hard coded contract values instead of storage variables, saves around 8,500 in gas per TX.
+ //Since contract is upgradeable, we can update these values as well with it.
+ bytes memory _routing_info = "secret10hwq375veu49khx9dkcl6249n6fc2u5tft50jp";
+ bytes memory _routing_code_hash = "d94d2cd7d22f0509c7ca0b80d6576ecfebf2618c6026204c30a35f6624cb3230";
+
+ bytes memory payload = bytes.concat(
bytes23(0x7b2264617461223a227b5c226e756d576f7264735c223a), //bytes representation of '{"data":"{\"numWords\":' because solidity has problems with correct string escaping of numWords
- Encoders.uint256toString(_numWords),
- '}","routing_info": "',routing_info,
- '","routing_code_hash": "',routing_code_hash,
- '","user_address": "0x0000000000000000000000000000000000000000",', //unused user_address here
- '"user_key": "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA",', // 33 bytes of zeros in base64
- '"callback_address": "', callback_address,
+ bytes(uint256toString(_numWords)),
+ '}","routing_info": "',_routing_info,
+ '","routing_code_hash": "',_routing_code_hash,
+ '","user_address": "0x0000000000000000000000000000000000000000","user_key": "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA",', //unused user_address here + + 33 bytes of zeros in base64 for user_key
+ '"callback_address": "', bytes(callback_address),
'","callback_selector": "OLpGFA==",', // 0x38ba4614 hex value already converted into base64, callback_selector of the fullfillRandomWords function
- '"callback_gas_limit": ', Encoders.uint256toString(_callbackGasLimit),'}' // Corrected function call
+ '"callback_gas_limit": ', bytes(uint256toString(_callbackGasLimit)),'}'
);
- bytes32 payloadHash = keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32",keccak256(payload)));
+ bytes32 payloadHash = keccak256(bytes.concat("\x19Ethereum Signed Message:\n32", keccak256(payload)));
// ExecutionInfo struct
ExecutionInfo memory executionInfo = ExecutionInfo({
user_key: new bytes(33), // equals AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA in base64
user_pubkey: new bytes(64), // Fill with 0 bytes
- routing_code_hash: routing_code_hash,
+ routing_code_hash: string(_routing_code_hash),
handle: "request_random",
nonce: bytes12(0),
- payload: payload, // Make sure payload is correctly formatted
+ payload: payload,
payload_signature: new bytes(64) // empty signature, fill with 0 bytes
});
+ uint256 oldTaskId = taskId;
// persisting the task
- tasks[taskId] = ReducedTask(sliceLastByte(payloadHash), false);
+ tasks[oldTaskId] = ReducedTask(sliceLastByte(payloadHash), false);
emit logNewTask(
taskId,
- chainIdentifier,
+ uint256toString(block.chainid),
msg.sender,
- routing_info,
+ string(_routing_info),
payloadHash,
executionInfo
);
- uint256 oldTaskId = taskId;
+
taskId++;
return oldTaskId;
}
@@ -280,158 +392,86 @@ contract Gateway {
Post Execution
//////////////////////////////////////////////////////////////*/
- /// @notice Post-Execution
- /// @param _taskId Task Id of the executed message
- /// @param _sourceNetwork Source network of the message
- /// @param _info PostExecutionInfo struct
+ /// @notice Handles the post-execution logic of a task
+ /// @param _taskId The ID of the task
+ /// @param _sourceNetwork The source network of the task
+ /// @param _info Post execution information
function postExecution(uint256 _taskId, string calldata _sourceNetwork, PostExecutionInfo calldata _info) external {
-
- ReducedTask storage task = tasks[_taskId];
+
+ ReducedTask storage task = tasks[_taskId];
- // Check if the task is already completed
- if (task.completed) {
- revert TaskAlreadyCompleted();
- }
-
- if (sliceLastByte(_info.payload_hash) != task.payload_hash_reduced) {
- revert InvalidPayloadHash();
- }
-
- address checkerAddress = route[_sourceNetwork];
-
- // Result signature verification
- if (recoverSigner(_info.result_hash, _info.result_signature) != checkerAddress) {
- revert InvalidResultSignature();
- }
+ // Check if the task is already completed
+ if (task.completed) {
+ revert TaskAlreadyCompleted();
+ }
- // Concatenate data elements
- bytes memory data = bytes.concat(
- bytes(_sourceNetwork),
- bytes(chainIdentifier),
- bytes32(_taskId),
- bytes32(_info.payload_hash),
- bytes(_info.result),
- bytes32(_info.result_hash),
- bytes20(_info.callback_address),
- bytes4(_info.callback_selector));
-
- // Perform Keccak256 + sha256 hash
- bytes32 packetHash = sha256(abi.encodePacked(keccak256(data)));
+ if (sliceLastByte(_info.payload_hash) != task.payload_hash_reduced) {
+ revert InvalidPayloadHash();
+ }
- // Packet signature verification
- if ((_info.packet_hash != packetHash) || recoverSigner(_info.packet_hash, _info.packet_signature) != checkerAddress) {
- revert InvalidPacketSignature();
- }
-
- task.completed = true;
+ address checkerAddress = route[_sourceNetwork];
- emit logCompletedTask(_taskId, _info.payload_hash, _info.result_hash);
+ // Result signature verification
+ if (recoverSigner(_info.result_hash, _info.result_signature) != checkerAddress) {
+ revert InvalidResultSignature();
+ }
- // Continue with the function execution
+ // Concatenate data elements
+ bytes memory data = bytes.concat(
+ bytes(_sourceNetwork),
+ bytes(uint256toString(block.chainid)),
+ bytes32(_taskId),
+ _info.payload_hash,
+ _info.result,
+ _info.result_hash,
+ _info.callback_address,
+ _info.callback_selector);
+
+ // Perform Keccak256 + sha256 hash
+ bytes32 packetHash = sha256(abi.encodePacked(keccak256(data)));
+
+ // Packet signature verification
+ if ((_info.packet_hash != packetHash) || recoverSigner(_info.packet_hash, _info.packet_signature) != checkerAddress) {
+ revert InvalidPacketSignature();
+ }
+
+ task.completed = true;
- // Additional conversion for Secret VRF into uint256[] if callback_selector matches the fullfillRandomWords selector.
+ emit logCompletedTask(_taskId, _info.payload_hash, _info.result_hash);
- bool val;
+ // Continue with the function execution
+ // Additional conversion for Secret VRF into uint256[] if callback_selector matches the fullfillRandomWords selector.
- if (_info.callback_selector == bytes4(0x38ba4614)) {
- uint256[] memory randomWords = Encoders.bytesToUint256Array(_info.result);
- (val, ) = address(_info.callback_address).call{gas: uint32(_info.callback_gas_limit)}(
- abi.encodeWithSelector(_info.callback_selector, _taskId, randomWords)
- );
- }
- else {
- (val, ) = address(_info.callback_address).call{gas: uint32(_info.callback_gas_limit)}(
- abi.encodeWithSelector(_info.callback_selector, _taskId, _info.result)
- );
- }
- if (!val) {
- revert CallbackError();
+ if (_info.callback_selector == bytes4(0x38ba4614)) {
+ uint256[] memory randomWords = bytesToUint256Array(_info.result);
+ IRandomness randomness = IRandomness(address(_info.callback_address));
+ randomness.fulfillRandomWords(_taskId, randomWords);
+ }
+ else {
+ bool val;
+ (val, ) = address(_info.callback_address).call{gas: uint32(_info.callback_gas_limit)}(
+ abi.encodeWithSelector(_info.callback_selector, _taskId, _info.result)
+ );
+ if (!val) {
+ revert CallbackError();
+ }
+ }
}
-}
/*//////////////////////////////////////////////////////////////
Callback
//////////////////////////////////////////////////////////////*/
- /// @param _taskId Task Id of the computation
- /// @param _result Privately computed result
+ /// @notice Emits an event with the result of a computation
+ /// @param _taskId The ID of the task
+ /// @param _result The result of the computation
+
function callback(uint256 _taskId, bytes calldata _result) external {
emit ComputedResult(_taskId, _result);
}
-}
-library Encoders {
-
- function encodeBase64(bytes memory data) internal pure returns (string memory) {
- if (data.length == 0) return "";
- string memory table = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
- string memory result = new string(4 * ((data.length + 2) / 3));
- /// @solidity memory-safe-assembly
- assembly {
- let tablePtr := add(table, 1)
- let resultPtr := add(result, 32)
- for {
- let dataPtr := data
- let endPtr := add(data, mload(data))
- } lt(dataPtr, endPtr) {
- } {
- dataPtr := add(dataPtr, 3)
- let input := mload(dataPtr)
- mstore8(resultPtr, mload(add(tablePtr, and(shr(18, input), 0x3F))))
- resultPtr := add(resultPtr, 1)
- mstore8(resultPtr, mload(add(tablePtr, and(shr(12, input), 0x3F))))
- resultPtr := add(resultPtr, 1)
- mstore8(resultPtr, mload(add(tablePtr, and(shr(6, input), 0x3F))))
- resultPtr := add(resultPtr, 1)
- mstore8(resultPtr, mload(add(tablePtr, and(input, 0x3F))))
- resultPtr := add(resultPtr, 1)
- }
- switch mod(mload(data), 3)
- case 1 {
- mstore8(sub(resultPtr, 1), 0x3d)
- mstore8(sub(resultPtr, 2), 0x3d)
- }
- case 2 {
- mstore8(sub(resultPtr, 1), 0x3d)
- }
- }
- return result;
- }
-
- function uint256toString(uint256 value) external pure returns (string memory ptr) {
- assembly {
- ptr := add(mload(0x40), 128)
- mstore(0x40, ptr)
- let end := ptr
- for {
- let temp := value
- ptr := sub(ptr, 1)
- mstore8(ptr, add(48, mod(temp, 10)))
- temp := div(temp, 10)
- } temp {
- temp := div(temp, 10)
- } {
- ptr := sub(ptr, 1)
- mstore8(ptr, add(48, mod(temp, 10)))
- }
- let length := sub(end, ptr)
- ptr := sub(ptr, 32)
- mstore(ptr, length)
- }
- }
-
- function bytesToUint256Array(bytes memory data) internal pure returns (uint256[] memory) {
- require(data.length % 32 == 0, "Data length must be a multiple of 32 bytes");
- uint256[] memory uintArray = new uint256[](data.length / 32);
- uint256 dataLength = data.length;
- assembly {
- let dataPtr := add(data, 0x20)
- let uintArrayPtr := add(uintArray, 0x20)
- for { let i := 0 } lt(i, dataLength) { i := add(i, 32) } {
- mstore(add(uintArrayPtr, i), mload(add(dataPtr, i)))
- }
- }
- return uintArray;
- }
+ /*//////////////////////////////////////////////////////////////
+ New Functions for Upgradeability
+ //////////////////////////////////////////////////////////////*/
}
\ No newline at end of file
diff --git a/TNLS-Gateways/public-gateway/src/RandomnessReciever.sol b/TNLS-Gateways/public-gateway/src/RandomnessReciever.sol
index aa3f435..079831e 100644
--- a/TNLS-Gateways/public-gateway/src/RandomnessReciever.sol
+++ b/TNLS-Gateways/public-gateway/src/RandomnessReciever.sol
@@ -1,10 +1,14 @@
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.23;
+interface ISecretVRF {
+ function requestRandomness(uint32 _numWords, uint32 _callbackGasLimit) external payable returns (uint256 requestId);
+}
+
contract RandomnessReciever {
- address private RNGGateway;
- address private immutable owner;
+ address public VRFGateway;
+ address public immutable owner;
constructor() {
owner = msg.sender;
@@ -15,34 +19,26 @@ contract RandomnessReciever {
_;
}
- function setGatewayAddress(address _RNGGateway) external onlyOwner {
- RNGGateway = _RNGGateway;
+ function setGatewayAddress(address _VRFGateway) external onlyOwner {
+ VRFGateway = _VRFGateway;
}
- function requestRandomWordsTest() external {
- bool success;
- bytes memory data;
- uint256 requestId;
- uint32 numWords = 50; // can be up to 50 words
- uint32 callbackGasLimit = 1000000;
- (success, data) = RNGGateway.call(abi.encodeWithSelector(bytes4(0x967b2017), numWords, callbackGasLimit));
- require(success, "External call failed");
- if (data.length == 32) {
- assembly {requestId := mload(add(data, 32))}
- } else {
- revert("Data returned is too short");
- }
+ function requestRandomnessTest() external {
+ uint32 numWords = 2000; // can be up to 2000 words
+ uint32 callbackGasLimit = 2000000;
+ ISecretVRF vrfContract = ISecretVRF(VRFGateway);
+ uint256 requestId = vrfContract.requestRandomness(numWords, callbackGasLimit);
}
event fulfilledRandomWords(uint256 requestId, uint256[] randomWords);
/*//////////////////////////////////////////////////////////////
- Callback
+ fulfillRandomWords Callback
//////////////////////////////////////////////////////////////*/
- function fulfillRandomWords(uint256 requestId, uint256[] memory randomWords) external {
- require(msg.sender == address(RNGGateway), "only Secret Gateway can fulfill");
+ function fulfillRandomWords(uint256 requestId, uint256[] calldata randomWords) external {
+ require(msg.sender == address(VRFGateway), "only Secret Gateway can fulfill");
//do your custom stuff here.
emit fulfilledRandomWords(requestId, randomWords);
}
diff --git a/TNLS-Gateways/public-gateway/test/Contract.t.sol b/TNLS-Gateways/public-gateway/test/Contract.t.sol
index 8222191..26607c6 100644
--- a/TNLS-Gateways/public-gateway/test/Contract.t.sol
+++ b/TNLS-Gateways/public-gateway/test/Contract.t.sol
@@ -51,7 +51,6 @@ contract ContractTest is Test {
require(_sig.length == 65, "invalid signature length");
assembly {
-
// first 32 bytes, after the length prefix
r := mload(add(_sig, 32))
// second 32 bytes
@@ -135,16 +134,12 @@ contract ContractTest is Test {
Test Cases
//////////////////////////////////////////////////////////////*/
- function test_CheckTheOwnerOfTheContract() public {
- address owner = gateway.owner();
- assertEq(deployer, owner);
- }
function test_OwnerCanInitialize() public {
vm.prank(deployer);
address tempAddress = vm.addr(5);
- gateway.initialize(tempAddress);
+ gateway.setMasterVerificationAddress(tempAddress);
assertEq(tempAddress, gateway.masterVerificationAddress());
}
@@ -152,7 +147,7 @@ contract ContractTest is Test {
function testFail_NonOwnerCannotInitialize() public {
vm.startPrank(notOwner);
address tempAddress = vm.addr(5);
- gateway.initialize(tempAddress);
+ gateway.setMasterVerificationAddress(tempAddress);
vm.stopPrank();
}
@@ -161,10 +156,10 @@ contract ContractTest is Test {
vm.prank(deployer);
address masterVerificationKey = vm.addr(2);
- gateway.initialize(masterVerificationKey);
+ gateway.setMasterVerificationAddress(masterVerificationKey);
address SampleVerificationAddress = vm.addr(6);
- string memory sampleRoute = "secret";
+ string memory sampleRoute = "secret-4";
// Update the route with with masterVerificationKey signature
bytes32 routeHash = getRouteHash(sampleRoute, SampleVerificationAddress);
@@ -176,7 +171,7 @@ contract ContractTest is Test {
vm.prank(deployer);
gateway.updateRoute(sampleRoute, SampleVerificationAddress, sig);
- assertEq(gateway.route("secret"), SampleVerificationAddress);
+ assertEq(gateway.route("secret-4"), SampleVerificationAddress);
}
function testFail_OwnerCannotUpdateRouteWithoutValidSignature() public {
@@ -184,7 +179,7 @@ contract ContractTest is Test {
vm.prank(deployer);
address masterVerificationKey = vm.addr(5);
- gateway.initialize(masterVerificationKey);
+ gateway.setMasterVerificationAddress(masterVerificationKey);
address SampleVerificationAddress = vm.addr(6);
string memory sampleRoute = "secret";
@@ -207,7 +202,7 @@ contract ContractTest is Test {
vm.prank(deployer);
address masterVerificationKey = vm.addr(5);
- gateway.initialize(masterVerificationKey);
+ gateway.setMasterVerificationAddress(masterVerificationKey);
address SampleVerificationAddress = vm.addr(6);
string memory sampleRoute = "secret";
@@ -227,7 +222,7 @@ contract ContractTest is Test {
vm.prank(deployer);
address masterVerificationKey = vm.addr(5);
- gateway.initialize(masterVerificationKey);
+ gateway.setMasterVerificationAddress(masterVerificationKey);
address SampleVerificationAddress = vm.addr(6);
string memory sampleRoute = "secret";
@@ -272,16 +267,10 @@ contract ContractTest is Test {
gateway.send(vm.addr(5), sourceNetwork,routingInfo, payloadHash, assembledInfo, vm.addr(7), callbackSelector, 300000 );
- (bytes32 tempPayloadHash,,,,) = gateway.tasks(1);
+ (bytes31 tempPayloadHash,,,,) = gateway.tasks(1);
assertEq(tempPayloadHash, payloadHash, "payloadHash failed");
- (,address tempCallbackAddress,,,) = gateway.tasks(1);
- assertEq(tempCallbackAddress, vm.addr(7), "tempCallbackAddress failed");
-
- (,,bytes4 tempCallbackSelector,,) = gateway.tasks(1);
- assertEq(tempCallbackSelector, callbackSelector, "callbackSelector failed");
-
- (,,,, bool tempCompleted) = gateway.tasks(1);
+ (,bool tempCompleted) = gateway.tasks(1);
assertEq(tempCompleted, false, "tempCompleted failed");
}
@@ -435,7 +424,7 @@ contract ContractTest is Test {
vm.prank(deployer);
address masterVerificationKey = vm.addr(2);
- gateway.initialize(masterVerificationKey);
+ gateway.setMasterVerificationAddress(masterVerificationKey);
address SampleVerificationAddress = 0x49F7552065228e5abF44e144cc750aEA4F711Dc3;
string memory sampleRoute = "secret";
diff --git a/TNLS-Gateways/secret/contract.wasm.gz b/TNLS-Gateways/secret/contract.wasm.gz
index d8161bc..e746e6b 100644
Binary files a/TNLS-Gateways/secret/contract.wasm.gz and b/TNLS-Gateways/secret/contract.wasm.gz differ
diff --git a/TNLS-Gateways/secret/src/contract.rs b/TNLS-Gateways/secret/src/contract.rs
index 9b7cbbe..ba4e735 100644
--- a/TNLS-Gateways/secret/src/contract.rs
+++ b/TNLS-Gateways/secret/src/contract.rs
@@ -23,6 +23,7 @@ use sha3::{Digest, Keccak256};
/// pad handle responses and log attributes to blocks of 256 bytes to prevent leaking info based on
/// response size
pub const BLOCK_SIZE: usize = 256;
+pub const CHAIN_ID: &str = "secret-4";
#[cfg(feature = "contract")]
////////////////////////////////////// Init ///////////////////////////////////////
@@ -92,7 +93,7 @@ pub fn execute(
match msg {
ExecuteMsg::Input { inputs } => {
pad_handle_result(pre_execution(deps, env, inputs), BLOCK_SIZE)
- }
+ },
ExecuteMsg::Output { outputs } => post_execution(deps, env, outputs),
}
}
@@ -320,7 +321,7 @@ fn post_execution(deps: DepsMut, _env: Env, msg: PostExecutionMsg) -> StdResult<
// create hash of entire packet (used to verify the message wasn't modified in transit)
let data = [
- "secret".as_bytes(), // source network
+ CHAIN_ID.as_bytes(), // source network
routing_info.as_bytes(), // task_destination_network
task_id_padded.as_slice(), //msg.task_id.to_be_bytes().as_slice(), // task ID
// task_info.payload.as_slice(), // payload (original encrypted or unencrypted payload)
@@ -422,7 +423,7 @@ fn post_execution(deps: DepsMut, _env: Env, msg: PostExecutionMsg) -> StdResult<
let callback_gas_limit = format!("0x{}", task_info.callback_gas_limit.to_be_bytes().encode_hex::());
Ok(Response::new()
- .add_attribute_plaintext("source_network", "secret")
+ .add_attribute_plaintext("source_network", CHAIN_ID)
.add_attribute_plaintext("task_destination_network", routing_info)
.add_attribute_plaintext("task_id", msg.task_id.to_string())
.add_attribute_plaintext("payload_hash", payload_hash)
diff --git a/TNLS-Relayers/base_interface.py b/TNLS-Relayers/base_interface.py
index da1677d..761f73e 100644
--- a/TNLS-Relayers/base_interface.py
+++ b/TNLS-Relayers/base_interface.py
@@ -16,8 +16,8 @@
}
-task_keys_to_msg = {'ethereum': eth_task_keys_to_msg}
-task_keys_in_order = {'ethereum': ['_taskId', '_sourceNetwork', '_info']}
+task_keys_to_msg = {'11155111': eth_task_keys_to_msg}
+task_keys_in_order = {'11155111': ['_taskId', '_sourceNetwork', '_info']}
def to_dict(dict_to_parse, key_type=""):
@@ -96,7 +96,7 @@ def __init__(self, task_dict):
task_dict['routing_info'] = task_dict['routing_info'].split(':')[1]
task_dict['task_destination_network'] = self.task_destination_network
elif 'routing_info' in task_dict and 'secret' in task_dict['routing_info']:
- self.task_destination_network = 'secret'
+ self.task_destination_network = 'secret-4'
task_dict['task_destination_network'] = self.task_destination_network
elif 'routing_info' in task_dict:
self.task_destination_network = task_dict['routing_info']
@@ -117,7 +117,7 @@ def __str__(self):
return json.dumps(new_task_list)
return json.dumps(to_dict(new_task_dict, key_type=self.task_destination_network))
else:
- if 'task_id' in self.task_data and self.task_destination_network == 'secret':
+ if 'task_id' in self.task_data and self.task_destination_network == 'secret-4':
self.task_data['task_id'] = int(self.task_data['task_id'])
return json.dumps(to_dict(self.task_data))
diff --git a/TNLS-Relayers/eth_interface.py b/TNLS-Relayers/eth_interface.py
index 3546d74..c037b78 100644
--- a/TNLS-Relayers/eth_interface.py
+++ b/TNLS-Relayers/eth_interface.py
@@ -56,7 +56,7 @@ def create_transaction(self, contract_function, *args, **kwargs):
if kwargs is {}:
tx = contract_function(*args).build_transaction({
'from': self.address,
- 'gas': 1000000,
+ 'gas': 3000000,
'nonce': nonce,
#'maxFeePerGas': self.provider.eth.max_priority_fee
#'maxPriorityFeePerGas': self.provider.eth.max_priority_fee,
@@ -64,14 +64,14 @@ def create_transaction(self, contract_function, *args, **kwargs):
elif len(args) == 0:
tx = contract_function(**kwargs).build_transaction({
'from': self.address,
- 'gas': 1000000,
+ 'gas': 3000000,
'nonce': nonce,
#'maxPriorityFeePerGas': self.provider.eth.max_priority_fee,
})
else:
tx = contract_function(*args, **kwargs).build_transaction({
'from': self.address,
- 'gas': 1000000,
+ 'gas': 3000000,
'nonce': nonce,
#'maxPriorityFeePerGas': self.provider.eth.max_priority_fee,
})
diff --git a/TNLS-Relayers/relayer.py b/TNLS-Relayers/relayer.py
index c916303..d066452 100644
--- a/TNLS-Relayers/relayer.py
+++ b/TNLS-Relayers/relayer.py
@@ -71,7 +71,7 @@ def __init__(self,
# Setup keys dictionary
keys_dict = {
- 'secret': {
+ 'secret-4': {
'verification': verification_key,
'encryption': encryption_key
}
@@ -90,7 +90,7 @@ def __init__(self,
scrt_tuple = (scrt_base_interface, scrt_contract_interface, 'wasm', 'inputs')
# Create the dictionary and add the tuple
- self.dict_of_names_to_interfaces = {'ethereum': eth_tuple,'secret': scrt_tuple}
+ self.dict_of_names_to_interfaces = {'11155111': eth_tuple,'secret-4': scrt_tuple}
"""
Args:
@@ -136,11 +136,11 @@ def process_transaction(self, transaction, name, contract_interface, evt_name):
def poll_for_transactions(self):
for name, (chain_interface, contract_interface, evt_name, _) in self.dict_of_names_to_interfaces.items():
- if name == 'secret':
+ if name == 'secret-4' or name == 'pulsar-3':
continue
prev_height = self.dict_of_names_to_blocks[name]
curr_height = chain_interface.get_last_block()
- #curr_height = 5021399
+ #curr_height = 5029638
if prev_height is None:
prev_height = curr_height - 1
@@ -176,7 +176,7 @@ def route_transaction(self, task: Task):
return
contract_for_txn = self.dict_of_names_to_interfaces[task.task_destination_network][1]
function_name = self.dict_of_names_to_interfaces[task.task_destination_network][3]
- if task.task_destination_network == 'secret':
+ if task.task_destination_network == 'secret-4':
ntasks, _ = contract_for_txn.call_function(function_name, str(task))
self.task_list.extend(ntasks)
else:
diff --git a/TNLS-Samples/RNG/contract.wasm.gz b/TNLS-Samples/RNG/contract.wasm.gz
index 71db02e..bcdd186 100644
Binary files a/TNLS-Samples/RNG/contract.wasm.gz and b/TNLS-Samples/RNG/contract.wasm.gz differ
diff --git a/TNLS-Samples/RNG/src/contract.rs b/TNLS-Samples/RNG/src/contract.rs
index b5efd81..41f1895 100644
--- a/TNLS-Samples/RNG/src/contract.rs
+++ b/TNLS-Samples/RNG/src/contract.rs
@@ -37,8 +37,7 @@ pub fn instantiate(
#[entry_point]
pub fn execute(deps: DepsMut, env: Env, info: MessageInfo, msg: ExecuteMsg) -> StdResult {
let response = match msg {
- ExecuteMsg::Input { message } => try_handle(deps, env, info, message),
- ExecuteMsg::ReturnRandom {} => return_random(deps, env, info),
+ ExecuteMsg::Input { message } => try_handle(deps, env, info, message)
};
pad_handle_result(response, BLOCK_SIZE)
}
@@ -46,7 +45,7 @@ pub fn execute(deps: DepsMut, env: Env, info: MessageInfo, msg: ExecuteMsg) -> S
#[entry_point]
pub fn query(deps: Deps, _env: Env, msg: QueryMsg) -> StdResult {
let response = match msg {
- QueryMsg::Query {} => try_query(deps),
+ QueryMsg::Query {} => try_query(deps)
};
pad_query_result(response, BLOCK_SIZE)
}
@@ -78,20 +77,6 @@ fn try_handle(
}
}
-fn return_random(
- _deps: DepsMut,
- env: Env,
- _info: MessageInfo,
-) -> StdResult {
-
- let result = match env.block.random {
- Some(random_value) => random_value.to_base64(),
- None => return Err(StdError::generic_err("No random value available")),
- };
-
- Ok(Response::new().add_attribute("random", result))
-}
-
fn try_random(
deps: DepsMut,
env: Env,
diff --git a/TNLS-Samples/RNG/src/msg.rs b/TNLS-Samples/RNG/src/msg.rs
index 0143d22..112069a 100644
--- a/TNLS-Samples/RNG/src/msg.rs
+++ b/TNLS-Samples/RNG/src/msg.rs
@@ -15,14 +15,13 @@ pub struct InstantiateMsg {
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
#[serde(rename_all = "snake_case")]
pub enum ExecuteMsg {
- Input { message: PrivContractHandleMsg },
- ReturnRandom {},
+ Input { message: PrivContractHandleMsg }
}
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
#[serde(rename_all = "snake_case")]
pub enum QueryMsg {
- Query {},
+ Query {}
}
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
diff --git a/TNLS-Samples/RNG/tests/integration.ts b/TNLS-Samples/RNG/tests/integration.ts
index 641072d..a1d1d1d 100644
--- a/TNLS-Samples/RNG/tests/integration.ts
+++ b/TNLS-Samples/RNG/tests/integration.ts
@@ -46,8 +46,6 @@ const initializeClient = async (endpoint: string, chainId: string) => {
const initializeGateway = async (
client: SecretNetworkClient,
contractPath: string,
- scrtRngHash: string,
- scrtRngAddress: string,
) => {
const wasmCode = fs.readFileSync(contractPath);
console.log("Uploading gateway contract...");
@@ -91,11 +89,7 @@ const initializeGateway = async (
{
sender: client.address,
code_id: codeId,
- init_msg: {
- entropy: "secret",
- rng_hash: scrtRngHash,
- rng_addr: scrtRngAddress,
- },
+ init_msg: {},
code_hash: contractCodeHash.code_hash,
label: "My contract" + Math.ceil(Math.random() * 10000), // The label should be unique for every contract, add random string in order to maintain uniqueness
},
@@ -170,7 +164,7 @@ const initializeScrtRng = async (
{
sender: client.address,
code_id: codeId,
- init_msg: { initseed: "secret", prng_seed: "secret" },
+ init_msg: {},
code_hash: contractCodeHash.code_hash,
label: "My contract" + Math.ceil(Math.random() * 10000), // The label should be unique for every contract, add random string in order to maintain uniqueness
},