contract-proxy-kit
Version:
Enable batched transactions and contract account interactions using a unique deterministic Gnosis Safe.
143 lines • 6.45 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, privateMap, value) {
if (!privateMap.has(receiver)) {
throw new TypeError("attempted to set private field on non-instance");
}
privateMap.set(receiver, value);
return value;
};
var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, privateMap) {
if (!privateMap.has(receiver)) {
throw new TypeError("attempted to get private field on non-instance");
}
return privateMap.get(receiver);
};
var _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 }) {
_speed.set(this, void 0);
__classPrivateFieldSet(this, _speed, speed);
}
get config() {
return {
name: TransactionManagerNames.RocksideTxRelayManager,
speed: __classPrivateFieldGet(this, _speed)
};
}
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, _speed)];
});
}
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, _speed) }),
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);
});
}
}
_speed = new WeakMap();
export default RocksideRelayTransactionManager;
//# sourceMappingURL=index.js.map