dp-contract-proxy-kit
Version:
Enable batched transactions and contract account interactions using a unique deterministic Gnosis Safe.
141 lines • 7.22 kB
JavaScript
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
};
var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
if (kind === "m") throw new TypeError("Private method is not writable");
if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
};
var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
};
var _RocksideRelayTransactionManager_speed;
import BigNumber from 'bignumber.js';
import { rocksideTxRelayUrl } from '../../config/transactionManagers';
import { zeroAddress } from '../../utils/constants';
import { HttpMethod, sendRequest } from '../../utils/httpRequests';
import { TransactionManagerNames } from '../TransactionManager';
import { getTransactionHashSignature } from '../utils';
export var RocksideSpeed;
(function (RocksideSpeed) {
RocksideSpeed["Fast"] = "fast";
RocksideSpeed["Fastest"] = "fastest";
RocksideSpeed["Safelow"] = "safelow";
RocksideSpeed["Standard"] = "standard";
})(RocksideSpeed || (RocksideSpeed = {}));
class RocksideRelayTransactionManager {
constructor({ speed }) {
_RocksideRelayTransactionManager_speed.set(this, void 0);
__classPrivateFieldSet(this, _RocksideRelayTransactionManager_speed, speed, "f");
}
get config() {
return {
name: TransactionManagerNames.RocksideTxRelayManager,
speed: __classPrivateFieldGet(this, _RocksideRelayTransactionManager_speed, "f")
};
}
execTransactions({ ownerAccount, safeExecTxParams, contractManager, ethLibAdapter }) {
return __awaiter(this, void 0, void 0, function* () {
const { contract } = contractManager;
if (!contract) {
throw new Error('CPK Proxy contract uninitialized');
}
let network;
const networkId = yield ethLibAdapter.getNetworkId();
switch (networkId) {
case 1:
network = 'mainnet';
break;
case 3:
network = 'ropsten';
break;
default:
throw new Error('Network not supported when using Rockside transaction relay');
}
const nonce = yield contract.call('nonce', []);
const txRelayParams = yield this.getTxRelayParams(contract.address, network);
const safeTransaction = {
to: safeExecTxParams.to,
value: safeExecTxParams.value,
data: safeExecTxParams.data,
operation: safeExecTxParams.operation,
safeTxGas: 0,
baseGas: 0,
gasPrice: Number(txRelayParams.gas_price),
gasToken: zeroAddress,
refundReceiver: txRelayParams.relayer,
nonce
};
const transactionHash = yield contract.call('getTransactionHash', [
safeTransaction.to,
new BigNumber(safeExecTxParams.value).toString(10),
safeTransaction.data,
safeTransaction.operation,
safeTransaction.safeTxGas,
safeTransaction.baseGas,
safeTransaction.gasPrice,
safeTransaction.gasToken,
safeTransaction.refundReceiver,
safeTransaction.nonce
]);
const signatures = yield getTransactionHashSignature(ethLibAdapter, ownerAccount, transactionHash);
const data = contract.encode('execTransaction', [
safeTransaction.to,
new BigNumber(safeExecTxParams.value).toString(10),
safeTransaction.data,
safeTransaction.operation,
safeTransaction.safeTxGas,
safeTransaction.baseGas,
safeTransaction.gasPrice,
safeTransaction.gasToken,
safeTransaction.refundReceiver,
signatures
]);
const trackingId = yield this.sendTxToRelay(contract.address, data, network);
return this.followTransaction(network, trackingId, ethLibAdapter);
});
}
getTxRelayParams(safeAccount, network) {
return __awaiter(this, void 0, void 0, function* () {
const jsonResponse = yield sendRequest({
url: `${rocksideTxRelayUrl}/ethereum/${network}/relay/${safeAccount}/params`,
method: HttpMethod.GET,
expectedHttpCodeResponse: 200
});
return jsonResponse.speeds[__classPrivateFieldGet(this, _RocksideRelayTransactionManager_speed, "f")];
});
}
sendTxToRelay(safeAccount, data, network) {
return __awaiter(this, void 0, void 0, function* () {
const jsonResponse = yield sendRequest({
url: `${rocksideTxRelayUrl}/ethereum/${network}/relay/${safeAccount}`,
method: HttpMethod.POST,
body: JSON.stringify({ data, speed: __classPrivateFieldGet(this, _RocksideRelayTransactionManager_speed, "f") }),
expectedHttpCodeResponse: 200
});
return jsonResponse.tracking_id;
});
}
followTransaction(network, trackingId, ethLibAdapter) {
return __awaiter(this, void 0, void 0, function* () {
const jsonResponse = yield sendRequest({
url: `${rocksideTxRelayUrl}/ethereum/${network}/transactions/${trackingId}`,
method: HttpMethod.GET,
expectedHttpCodeResponse: 200
});
return ethLibAdapter.toRocksideRelayTxResult(jsonResponse);
});
}
}
_RocksideRelayTransactionManager_speed = new WeakMap();
export default RocksideRelayTransactionManager;
//# sourceMappingURL=index.js.map