Socket
Socket
Sign inDemoInstall

@eth-optimism/sdk

Package Overview
Dependencies
Maintainers
2
Versions
498
Alerts
File Explorer

Advanced tools

License
Socket logo

Install Socket

Detect and block malicious and high-risk dependencies

Install

@eth-optimism/sdk - npm Package Compare versions

Comparing version 0.0.0-main-20240610203833 to 0.0.0-main-20240610222650

156

dist/adapters/dai-bridge.js
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
if (typeof b !== "function" && b !== null)
throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
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 __generator = (this && this.__generator) || function (thisArg, body) {
var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
function verb(n) { return function (v) { return step([n, v]); }; }
function step(op) {
if (f) throw new TypeError("Generator is already executing.");
while (g && (g = 0, op[0] && (_ = 0)), _) try {
if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
if (y = 0, t) op = [op[0] & 2, t.value];
switch (op[0]) {
case 0: case 1: t = op; break;
case 4: _.label++; return { value: op[1], done: false };
case 5: _.label++; y = op[1]; op = [0]; continue;
case 7: op = _.ops.pop(); _.trys.pop(); continue;
default:
if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
if (t[2]) _.ops.pop();
_.trys.pop(); continue;
}
op = body.call(thisArg, _);
} catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
}
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.DAIBridgeAdapter = void 0;
var core_utils_1 = require("@eth-optimism/core-utils");
var ethers_1 = require("ethers");
var utils_1 = require("../utils");
var standard_bridge_1 = require("./standard-bridge");
var DAIBridgeAdapter = (function (_super) {
__extends(DAIBridgeAdapter, _super);
function DAIBridgeAdapter() {
return _super !== null && _super.apply(this, arguments) || this;
const core_utils_1 = require("@eth-optimism/core-utils");
const ethers_1 = require("ethers");
const utils_1 = require("../utils");
const standard_bridge_1 = require("./standard-bridge");
class DAIBridgeAdapter extends standard_bridge_1.StandardBridgeAdapter {
async supportsTokenPair(l1Token, l2Token) {
const l1Bridge = new ethers_1.Contract(this.l1Bridge.address, [
{
inputs: [],
name: 'l1Token',
outputs: [
{
internalType: 'address',
name: '',
type: 'address',
},
],
stateMutability: 'view',
type: 'function',
},
{
inputs: [],
name: 'l2Token',
outputs: [
{
internalType: 'address',
name: '',
type: 'address',
},
],
stateMutability: 'view',
type: 'function',
},
], this.messenger.l1Provider);
const allowedL1Token = await l1Bridge.l1Token();
if (!(0, core_utils_1.hexStringEquals)(allowedL1Token, (0, utils_1.toAddress)(l1Token))) {
return false;
}
const allowedL2Token = await l1Bridge.l2Token();
if (!(0, core_utils_1.hexStringEquals)(allowedL2Token, (0, utils_1.toAddress)(l2Token))) {
return false;
}
return true;
}
DAIBridgeAdapter.prototype.supportsTokenPair = function (l1Token, l2Token) {
return __awaiter(this, void 0, void 0, function () {
var l1Bridge, allowedL1Token, allowedL2Token;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
l1Bridge = new ethers_1.Contract(this.l1Bridge.address, [
{
inputs: [],
name: 'l1Token',
outputs: [
{
internalType: 'address',
name: '',
type: 'address',
},
],
stateMutability: 'view',
type: 'function',
},
{
inputs: [],
name: 'l2Token',
outputs: [
{
internalType: 'address',
name: '',
type: 'address',
},
],
stateMutability: 'view',
type: 'function',
},
], this.messenger.l1Provider);
return [4, l1Bridge.l1Token()];
case 1:
allowedL1Token = _a.sent();
if (!(0, core_utils_1.hexStringEquals)(allowedL1Token, (0, utils_1.toAddress)(l1Token))) {
return [2, false];
}
return [4, l1Bridge.l2Token()];
case 2:
allowedL2Token = _a.sent();
if (!(0, core_utils_1.hexStringEquals)(allowedL2Token, (0, utils_1.toAddress)(l2Token))) {
return [2, false];
}
return [2, true];
}
});
});
};
return DAIBridgeAdapter;
}(standard_bridge_1.StandardBridgeAdapter));
}
exports.DAIBridgeAdapter = DAIBridgeAdapter;

162

dist/adapters/eco-bridge.js
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
if (typeof b !== "function" && b !== null)
throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
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 __generator = (this && this.__generator) || function (thisArg, body) {
var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
function verb(n) { return function (v) { return step([n, v]); }; }
function step(op) {
if (f) throw new TypeError("Generator is already executing.");
while (g && (g = 0, op[0] && (_ = 0)), _) try {
if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
if (y = 0, t) op = [op[0] & 2, t.value];
switch (op[0]) {
case 0: case 1: t = op; break;
case 4: _.label++; return { value: op[1], done: false };
case 5: _.label++; y = op[1]; op = [0]; continue;
case 7: op = _.ops.pop(); _.trys.pop(); continue;
default:
if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
if (t[2]) _.ops.pop();
_.trys.pop(); continue;
}
op = body.call(thisArg, _);
} catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
}
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.ECOBridgeAdapter = void 0;
var core_utils_1 = require("@eth-optimism/core-utils");
var ethers_1 = require("ethers");
var utils_1 = require("../utils");
var standard_bridge_1 = require("./standard-bridge");
var ECOBridgeAdapter = (function (_super) {
__extends(ECOBridgeAdapter, _super);
function ECOBridgeAdapter() {
return _super !== null && _super.apply(this, arguments) || this;
const core_utils_1 = require("@eth-optimism/core-utils");
const ethers_1 = require("ethers");
const utils_1 = require("../utils");
const standard_bridge_1 = require("./standard-bridge");
class ECOBridgeAdapter extends standard_bridge_1.StandardBridgeAdapter {
async supportsTokenPair(l1Token, l2Token) {
const l1Bridge = new ethers_1.Contract(this.l1Bridge.address, [
{
inputs: [],
name: 'l1Eco',
outputs: [
{
internalType: 'address',
name: '',
type: 'address',
},
],
stateMutability: 'view',
type: 'function',
},
], this.messenger.l1Provider);
const l2Bridge = new ethers_1.Contract(this.l2Bridge.address, [
{
inputs: [],
name: 'l2Eco',
outputs: [
{
internalType: 'contract L2ECO',
name: '',
type: 'address',
},
],
stateMutability: 'view',
type: 'function',
},
], this.messenger.l2Provider);
const [remoteL1Token, remoteL2Token] = await Promise.all([
l1Bridge.l1Eco(),
l2Bridge.l2Eco(),
]);
if (!(0, core_utils_1.hexStringEquals)(remoteL1Token, (0, utils_1.toAddress)(l1Token))) {
return false;
}
if (!(0, core_utils_1.hexStringEquals)(remoteL2Token, (0, utils_1.toAddress)(l2Token))) {
return false;
}
return true;
}
ECOBridgeAdapter.prototype.supportsTokenPair = function (l1Token, l2Token) {
return __awaiter(this, void 0, void 0, function () {
var l1Bridge, l2Bridge, _a, remoteL1Token, remoteL2Token;
return __generator(this, function (_b) {
switch (_b.label) {
case 0:
l1Bridge = new ethers_1.Contract(this.l1Bridge.address, [
{
inputs: [],
name: 'l1Eco',
outputs: [
{
internalType: 'address',
name: '',
type: 'address',
},
],
stateMutability: 'view',
type: 'function',
},
], this.messenger.l1Provider);
l2Bridge = new ethers_1.Contract(this.l2Bridge.address, [
{
inputs: [],
name: 'l2Eco',
outputs: [
{
internalType: 'contract L2ECO',
name: '',
type: 'address',
},
],
stateMutability: 'view',
type: 'function',
},
], this.messenger.l2Provider);
return [4, Promise.all([
l1Bridge.l1Eco(),
l2Bridge.l2Eco(),
])];
case 1:
_a = _b.sent(), remoteL1Token = _a[0], remoteL2Token = _a[1];
if (!(0, core_utils_1.hexStringEquals)(remoteL1Token, (0, utils_1.toAddress)(l1Token))) {
return [2, false];
}
if (!(0, core_utils_1.hexStringEquals)(remoteL2Token, (0, utils_1.toAddress)(l2Token))) {
return [2, false];
}
return [2, true];
}
});
});
};
return ECOBridgeAdapter;
}(standard_bridge_1.StandardBridgeAdapter));
}
exports.ECOBridgeAdapter = ECOBridgeAdapter;

281

dist/adapters/eth-bridge.js
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
if (typeof b !== "function" && b !== null)
throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
var __assign = (this && this.__assign) || function () {
__assign = Object.assign || function(t) {
for (var s, i = 1, n = arguments.length; i < n; i++) {
s = arguments[i];
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
t[p] = s[p];
}
return t;
};
return __assign.apply(this, arguments);
};
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 __generator = (this && this.__generator) || function (thisArg, body) {
var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
function verb(n) { return function (v) { return step([n, v]); }; }
function step(op) {
if (f) throw new TypeError("Generator is already executing.");
while (g && (g = 0, op[0] && (_ = 0)), _) try {
if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
if (y = 0, t) op = [op[0] & 2, t.value];
switch (op[0]) {
case 0: case 1: t = op; break;
case 4: _.label++; return { value: op[1], done: false };
case 5: _.label++; y = op[1]; op = [0]; continue;
case 7: op = _.ops.pop(); _.trys.pop(); continue;
default:
if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
if (t[2]) _.ops.pop();
_.trys.pop(); continue;
}
op = body.call(thisArg, _);
} catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
}
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.ETHBridgeAdapter = void 0;
var contracts_1 = require("@eth-optimism/contracts");
var core_utils_1 = require("@eth-optimism/core-utils");
var ethers_1 = require("ethers");
var interfaces_1 = require("../interfaces");
var utils_1 = require("../utils");
var standard_bridge_1 = require("./standard-bridge");
var ETHBridgeAdapter = (function (_super) {
__extends(ETHBridgeAdapter, _super);
function ETHBridgeAdapter() {
var _this = _super !== null && _super.apply(this, arguments) || this;
_this.populateTransaction = {
approve: function (l1Token, l2Token, amount, opts) { return __awaiter(_this, void 0, void 0, function () {
return __generator(this, function (_a) {
throw new Error("approvals not necessary for ETH bridge");
});
}); },
deposit: function (l1Token, l2Token, amount, opts) { return __awaiter(_this, void 0, void 0, function () {
return __generator(this, function (_a) {
switch (_a.label) {
case 0: return [4, this.supportsTokenPair(l1Token, l2Token)];
case 1:
if (!(_a.sent())) {
throw new Error("token pair not supported by bridge");
}
if ((opts === null || opts === void 0 ? void 0 : opts.recipient) === undefined) {
return [2, this.l1Bridge.populateTransaction.depositETH((opts === null || opts === void 0 ? void 0 : opts.l2GasLimit) || 200000, '0x', __assign(__assign({}, (0, utils_1.omit)((opts === null || opts === void 0 ? void 0 : opts.overrides) || {}, 'value')), { value: amount }))];
}
else {
return [2, this.l1Bridge.populateTransaction.depositETHTo((0, utils_1.toAddress)(opts.recipient), (opts === null || opts === void 0 ? void 0 : opts.l2GasLimit) || 200000, '0x', __assign(__assign({}, (0, utils_1.omit)((opts === null || opts === void 0 ? void 0 : opts.overrides) || {}, 'value')), { value: amount }))];
}
return [2];
}
});
}); },
withdraw: function (l1Token, l2Token, amount, opts) { return __awaiter(_this, void 0, void 0, function () {
return __generator(this, function (_a) {
switch (_a.label) {
case 0: return [4, this.supportsTokenPair(l1Token, l2Token)];
case 1:
if (!(_a.sent())) {
throw new Error("token pair not supported by bridge");
}
if ((opts === null || opts === void 0 ? void 0 : opts.recipient) === undefined) {
return [2, this.l2Bridge.populateTransaction.withdraw((0, utils_1.toAddress)(l2Token), amount, 0, '0x', __assign(__assign({}, (0, utils_1.omit)((opts === null || opts === void 0 ? void 0 : opts.overrides) || {}, 'value')), { value: this.messenger.bedrock ? amount : 0 }))];
}
else {
return [2, this.l2Bridge.populateTransaction.withdrawTo((0, utils_1.toAddress)(l2Token), (0, utils_1.toAddress)(opts.recipient), amount, 0, '0x', __assign(__assign({}, (0, utils_1.omit)((opts === null || opts === void 0 ? void 0 : opts.overrides) || {}, 'value')), { value: this.messenger.bedrock ? amount : 0 }))];
}
return [2];
}
});
}); },
const contracts_1 = require("@eth-optimism/contracts");
const core_utils_1 = require("@eth-optimism/core-utils");
const ethers_1 = require("ethers");
const interfaces_1 = require("../interfaces");
const utils_1 = require("../utils");
const standard_bridge_1 = require("./standard-bridge");
class ETHBridgeAdapter extends standard_bridge_1.StandardBridgeAdapter {
constructor() {
super(...arguments);
this.populateTransaction = {
approve: async (l1Token, l2Token, amount, opts) => {
throw new Error(`approvals not necessary for ETH bridge`);
},
deposit: async (l1Token, l2Token, amount, opts) => {
if (!(await this.supportsTokenPair(l1Token, l2Token))) {
throw new Error(`token pair not supported by bridge`);
}
if ((opts === null || opts === void 0 ? void 0 : opts.recipient) === undefined) {
return this.l1Bridge.populateTransaction.depositETH((opts === null || opts === void 0 ? void 0 : opts.l2GasLimit) || 200000, '0x', Object.assign(Object.assign({}, (0, utils_1.omit)((opts === null || opts === void 0 ? void 0 : opts.overrides) || {}, 'value')), { value: amount }));
}
else {
return this.l1Bridge.populateTransaction.depositETHTo((0, utils_1.toAddress)(opts.recipient), (opts === null || opts === void 0 ? void 0 : opts.l2GasLimit) || 200000, '0x', Object.assign(Object.assign({}, (0, utils_1.omit)((opts === null || opts === void 0 ? void 0 : opts.overrides) || {}, 'value')), { value: amount }));
}
},
withdraw: async (l1Token, l2Token, amount, opts) => {
if (!(await this.supportsTokenPair(l1Token, l2Token))) {
throw new Error(`token pair not supported by bridge`);
}
if ((opts === null || opts === void 0 ? void 0 : opts.recipient) === undefined) {
return this.l2Bridge.populateTransaction.withdraw((0, utils_1.toAddress)(l2Token), amount, 0, '0x', Object.assign(Object.assign({}, (0, utils_1.omit)((opts === null || opts === void 0 ? void 0 : opts.overrides) || {}, 'value')), { value: this.messenger.bedrock ? amount : 0 }));
}
else {
return this.l2Bridge.populateTransaction.withdrawTo((0, utils_1.toAddress)(l2Token), (0, utils_1.toAddress)(opts.recipient), amount, 0, '0x', Object.assign(Object.assign({}, (0, utils_1.omit)((opts === null || opts === void 0 ? void 0 : opts.overrides) || {}, 'value')), { value: this.messenger.bedrock ? amount : 0 }));
}
},
};
return _this;
}
ETHBridgeAdapter.prototype.approval = function (l1Token, l2Token, signer) {
return __awaiter(this, void 0, void 0, function () {
return __generator(this, function (_a) {
throw new Error("approval not necessary for ETH bridge");
});
async approval(l1Token, l2Token, signer) {
throw new Error(`approval not necessary for ETH bridge`);
}
async getDepositsByAddress(address, opts) {
const events = await this.l1Bridge.queryFilter(this.l1Bridge.filters.ETHDepositInitiated(address), opts === null || opts === void 0 ? void 0 : opts.fromBlock, opts === null || opts === void 0 ? void 0 : opts.toBlock);
return events
.map((event) => {
return {
direction: interfaces_1.MessageDirection.L1_TO_L2,
from: event.args.from,
to: event.args.to,
l1Token: ethers_1.ethers.constants.AddressZero,
l2Token: contracts_1.predeploys.OVM_ETH,
amount: event.args.amount,
data: event.args.extraData,
logIndex: event.logIndex,
blockNumber: event.blockNumber,
transactionHash: event.transactionHash,
};
})
.sort((a, b) => {
return b.blockNumber - a.blockNumber;
});
};
ETHBridgeAdapter.prototype.getDepositsByAddress = function (address, opts) {
return __awaiter(this, void 0, void 0, function () {
var events;
return __generator(this, function (_a) {
switch (_a.label) {
case 0: return [4, this.l1Bridge.queryFilter(this.l1Bridge.filters.ETHDepositInitiated(address), opts === null || opts === void 0 ? void 0 : opts.fromBlock, opts === null || opts === void 0 ? void 0 : opts.toBlock)];
case 1:
events = _a.sent();
return [2, events
.map(function (event) {
return {
direction: interfaces_1.MessageDirection.L1_TO_L2,
from: event.args.from,
to: event.args.to,
l1Token: ethers_1.ethers.constants.AddressZero,
l2Token: contracts_1.predeploys.OVM_ETH,
amount: event.args.amount,
data: event.args.extraData,
logIndex: event.logIndex,
blockNumber: event.blockNumber,
transactionHash: event.transactionHash,
};
})
.sort(function (a, b) {
return b.blockNumber - a.blockNumber;
})];
}
});
}
async getWithdrawalsByAddress(address, opts) {
const events = await this.l2Bridge.queryFilter(this.l2Bridge.filters.WithdrawalInitiated(undefined, undefined, address), opts === null || opts === void 0 ? void 0 : opts.fromBlock, opts === null || opts === void 0 ? void 0 : opts.toBlock);
return events
.filter((event) => {
return ((0, core_utils_1.hexStringEquals)(event.args.l1Token, ethers_1.ethers.constants.AddressZero) &&
(0, core_utils_1.hexStringEquals)(event.args.l2Token, contracts_1.predeploys.OVM_ETH));
})
.map((event) => {
return {
direction: interfaces_1.MessageDirection.L2_TO_L1,
from: event.args.from,
to: event.args.to,
l1Token: event.args.l1Token,
l2Token: event.args.l2Token,
amount: event.args.amount,
data: event.args.extraData,
logIndex: event.logIndex,
blockNumber: event.blockNumber,
transactionHash: event.transactionHash,
};
})
.sort((a, b) => {
return b.blockNumber - a.blockNumber;
});
};
ETHBridgeAdapter.prototype.getWithdrawalsByAddress = function (address, opts) {
return __awaiter(this, void 0, void 0, function () {
var events;
return __generator(this, function (_a) {
switch (_a.label) {
case 0: return [4, this.l2Bridge.queryFilter(this.l2Bridge.filters.WithdrawalInitiated(undefined, undefined, address), opts === null || opts === void 0 ? void 0 : opts.fromBlock, opts === null || opts === void 0 ? void 0 : opts.toBlock)];
case 1:
events = _a.sent();
return [2, events
.filter(function (event) {
return ((0, core_utils_1.hexStringEquals)(event.args.l1Token, ethers_1.ethers.constants.AddressZero) &&
(0, core_utils_1.hexStringEquals)(event.args.l2Token, contracts_1.predeploys.OVM_ETH));
})
.map(function (event) {
return {
direction: interfaces_1.MessageDirection.L2_TO_L1,
from: event.args.from,
to: event.args.to,
l1Token: event.args.l1Token,
l2Token: event.args.l2Token,
amount: event.args.amount,
data: event.args.extraData,
logIndex: event.logIndex,
blockNumber: event.blockNumber,
transactionHash: event.transactionHash,
};
})
.sort(function (a, b) {
return b.blockNumber - a.blockNumber;
})];
}
});
});
};
ETHBridgeAdapter.prototype.supportsTokenPair = function (l1Token, l2Token) {
return __awaiter(this, void 0, void 0, function () {
return __generator(this, function (_a) {
return [2, ((0, core_utils_1.hexStringEquals)((0, utils_1.toAddress)(l1Token), ethers_1.ethers.constants.AddressZero) &&
(0, core_utils_1.hexStringEquals)((0, utils_1.toAddress)(l2Token), contracts_1.predeploys.OVM_ETH))];
});
});
};
return ETHBridgeAdapter;
}(standard_bridge_1.StandardBridgeAdapter));
}
async supportsTokenPair(l1Token, l2Token) {
return ((0, core_utils_1.hexStringEquals)((0, utils_1.toAddress)(l1Token), ethers_1.ethers.constants.AddressZero) &&
(0, core_utils_1.hexStringEquals)((0, utils_1.toAddress)(l2Token), contracts_1.predeploys.OVM_ETH));
}
}
exports.ETHBridgeAdapter = ETHBridgeAdapter;

412

dist/adapters/standard-bridge.js
"use strict";
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 __generator = (this && this.__generator) || function (thisArg, body) {
var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
function verb(n) { return function (v) { return step([n, v]); }; }
function step(op) {
if (f) throw new TypeError("Generator is already executing.");
while (g && (g = 0, op[0] && (_ = 0)), _) try {
if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
if (y = 0, t) op = [op[0] & 2, t.value];
switch (op[0]) {
case 0: case 1: t = op; break;
case 4: _.label++; return { value: op[1], done: false };
case 5: _.label++; y = op[1]; op = [0]; continue;
case 7: op = _.ops.pop(); _.trys.pop(); continue;
default:
if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
if (t[2]) _.ops.pop();
_.trys.pop(); continue;
}
op = body.call(thisArg, _);
} catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
}
};
var __importDefault = (this && this.__importDefault) || function (mod) {

@@ -43,99 +7,53 @@ return (mod && mod.__esModule) ? mod : { "default": mod };

exports.StandardBridgeAdapter = void 0;
var contracts_1 = require("@eth-optimism/contracts");
var core_utils_1 = require("@eth-optimism/core-utils");
var ethers_1 = require("ethers");
var L1StandardBridge_json_1 = __importDefault(require("../forge-artifacts/L1StandardBridge.json"));
var L2StandardBridge_json_1 = __importDefault(require("../forge-artifacts/L2StandardBridge.json"));
var OptimismMintableERC20_json_1 = __importDefault(require("../forge-artifacts/OptimismMintableERC20.json"));
var interfaces_1 = require("../interfaces");
var utils_1 = require("../utils");
var StandardBridgeAdapter = (function () {
function StandardBridgeAdapter(opts) {
var _this = this;
const contracts_1 = require("@eth-optimism/contracts");
const core_utils_1 = require("@eth-optimism/core-utils");
const ethers_1 = require("ethers");
const L1StandardBridge_json_1 = __importDefault(require("../forge-artifacts/L1StandardBridge.json"));
const L2StandardBridge_json_1 = __importDefault(require("../forge-artifacts/L2StandardBridge.json"));
const OptimismMintableERC20_json_1 = __importDefault(require("../forge-artifacts/OptimismMintableERC20.json"));
const interfaces_1 = require("../interfaces");
const utils_1 = require("../utils");
class StandardBridgeAdapter {
constructor(opts) {
this.populateTransaction = {
approve: function (l1Token, l2Token, amount, opts) { return __awaiter(_this, void 0, void 0, function () {
var token;
return __generator(this, function (_a) {
switch (_a.label) {
case 0: return [4, this.supportsTokenPair(l1Token, l2Token)];
case 1:
if (!(_a.sent())) {
throw new Error("token pair not supported by bridge");
}
token = new ethers_1.Contract((0, utils_1.toAddress)(l1Token), OptimismMintableERC20_json_1.default.abi, this.messenger.l1Provider);
return [2, token.populateTransaction.approve(this.l1Bridge.address, amount, (opts === null || opts === void 0 ? void 0 : opts.overrides) || {})];
}
});
}); },
deposit: function (l1Token, l2Token, amount, opts) { return __awaiter(_this, void 0, void 0, function () {
return __generator(this, function (_a) {
switch (_a.label) {
case 0: return [4, this.supportsTokenPair(l1Token, l2Token)];
case 1:
if (!(_a.sent())) {
throw new Error("token pair not supported by bridge");
}
if ((opts === null || opts === void 0 ? void 0 : opts.recipient) === undefined) {
return [2, this.l1Bridge.populateTransaction.depositERC20((0, utils_1.toAddress)(l1Token), (0, utils_1.toAddress)(l2Token), amount, (opts === null || opts === void 0 ? void 0 : opts.l2GasLimit) || 200000, '0x', (opts === null || opts === void 0 ? void 0 : opts.overrides) || {})];
}
else {
return [2, this.l1Bridge.populateTransaction.depositERC20To((0, utils_1.toAddress)(l1Token), (0, utils_1.toAddress)(l2Token), (0, utils_1.toAddress)(opts.recipient), amount, (opts === null || opts === void 0 ? void 0 : opts.l2GasLimit) || 200000, '0x', (opts === null || opts === void 0 ? void 0 : opts.overrides) || {})];
}
return [2];
}
});
}); },
withdraw: function (l1Token, l2Token, amount, opts) { return __awaiter(_this, void 0, void 0, function () {
return __generator(this, function (_a) {
switch (_a.label) {
case 0: return [4, this.supportsTokenPair(l1Token, l2Token)];
case 1:
if (!(_a.sent())) {
throw new Error("token pair not supported by bridge");
}
if ((opts === null || opts === void 0 ? void 0 : opts.recipient) === undefined) {
return [2, this.l2Bridge.populateTransaction.withdraw((0, utils_1.toAddress)(l2Token), amount, 0, '0x', (opts === null || opts === void 0 ? void 0 : opts.overrides) || {})];
}
else {
return [2, this.l2Bridge.populateTransaction.withdrawTo((0, utils_1.toAddress)(l2Token), (0, utils_1.toAddress)(opts.recipient), amount, 0, '0x', (opts === null || opts === void 0 ? void 0 : opts.overrides) || {})];
}
return [2];
}
});
}); },
approve: async (l1Token, l2Token, amount, opts) => {
if (!(await this.supportsTokenPair(l1Token, l2Token))) {
throw new Error(`token pair not supported by bridge`);
}
const token = new ethers_1.Contract((0, utils_1.toAddress)(l1Token), OptimismMintableERC20_json_1.default.abi, this.messenger.l1Provider);
return token.populateTransaction.approve(this.l1Bridge.address, amount, (opts === null || opts === void 0 ? void 0 : opts.overrides) || {});
},
deposit: async (l1Token, l2Token, amount, opts) => {
if (!(await this.supportsTokenPair(l1Token, l2Token))) {
throw new Error(`token pair not supported by bridge`);
}
if ((opts === null || opts === void 0 ? void 0 : opts.recipient) === undefined) {
return this.l1Bridge.populateTransaction.depositERC20((0, utils_1.toAddress)(l1Token), (0, utils_1.toAddress)(l2Token), amount, (opts === null || opts === void 0 ? void 0 : opts.l2GasLimit) || 200000, '0x', (opts === null || opts === void 0 ? void 0 : opts.overrides) || {});
}
else {
return this.l1Bridge.populateTransaction.depositERC20To((0, utils_1.toAddress)(l1Token), (0, utils_1.toAddress)(l2Token), (0, utils_1.toAddress)(opts.recipient), amount, (opts === null || opts === void 0 ? void 0 : opts.l2GasLimit) || 200000, '0x', (opts === null || opts === void 0 ? void 0 : opts.overrides) || {});
}
},
withdraw: async (l1Token, l2Token, amount, opts) => {
if (!(await this.supportsTokenPair(l1Token, l2Token))) {
throw new Error(`token pair not supported by bridge`);
}
if ((opts === null || opts === void 0 ? void 0 : opts.recipient) === undefined) {
return this.l2Bridge.populateTransaction.withdraw((0, utils_1.toAddress)(l2Token), amount, 0, '0x', (opts === null || opts === void 0 ? void 0 : opts.overrides) || {});
}
else {
return this.l2Bridge.populateTransaction.withdrawTo((0, utils_1.toAddress)(l2Token), (0, utils_1.toAddress)(opts.recipient), amount, 0, '0x', (opts === null || opts === void 0 ? void 0 : opts.overrides) || {});
}
},
};
this.estimateGas = {
approve: function (l1Token, l2Token, amount, opts) { return __awaiter(_this, void 0, void 0, function () {
var _a, _b;
return __generator(this, function (_c) {
switch (_c.label) {
case 0:
_b = (_a = this.messenger.l1Provider).estimateGas;
return [4, this.populateTransaction.approve(l1Token, l2Token, amount, opts)];
case 1: return [2, _b.apply(_a, [_c.sent()])];
}
});
}); },
deposit: function (l1Token, l2Token, amount, opts) { return __awaiter(_this, void 0, void 0, function () {
var _a, _b;
return __generator(this, function (_c) {
switch (_c.label) {
case 0:
_b = (_a = this.messenger.l1Provider).estimateGas;
return [4, this.populateTransaction.deposit(l1Token, l2Token, amount, opts)];
case 1: return [2, _b.apply(_a, [_c.sent()])];
}
});
}); },
withdraw: function (l1Token, l2Token, amount, opts) { return __awaiter(_this, void 0, void 0, function () {
var _a, _b;
return __generator(this, function (_c) {
switch (_c.label) {
case 0:
_b = (_a = this.messenger.l2Provider).estimateGas;
return [4, this.populateTransaction.withdraw(l1Token, l2Token, amount, opts)];
case 1: return [2, _b.apply(_a, [_c.sent()])];
}
});
}); },
approve: async (l1Token, l2Token, amount, opts) => {
return this.messenger.l1Provider.estimateGas(await this.populateTransaction.approve(l1Token, l2Token, amount, opts));
},
deposit: async (l1Token, l2Token, amount, opts) => {
return this.messenger.l1Provider.estimateGas(await this.populateTransaction.deposit(l1Token, l2Token, amount, opts));
},
withdraw: async (l1Token, l2Token, amount, opts) => {
return this.messenger.l2Provider.estimateGas(await this.populateTransaction.withdraw(l1Token, l2Token, amount, opts));
},
};

@@ -146,157 +64,85 @@ this.messenger = opts.messenger;

}
StandardBridgeAdapter.prototype.getDepositsByAddress = function (address, opts) {
return __awaiter(this, void 0, void 0, function () {
var events;
return __generator(this, function (_a) {
switch (_a.label) {
case 0: return [4, this.l1Bridge.queryFilter(this.l1Bridge.filters.ERC20DepositInitiated(undefined, undefined, address), opts === null || opts === void 0 ? void 0 : opts.fromBlock, opts === null || opts === void 0 ? void 0 : opts.toBlock)];
case 1:
events = _a.sent();
return [2, events
.filter(function (event) {
return (!(0, core_utils_1.hexStringEquals)(event.args.l1Token, ethers_1.ethers.constants.AddressZero) &&
!(0, core_utils_1.hexStringEquals)(event.args.l2Token, contracts_1.predeploys.OVM_ETH));
})
.map(function (event) {
return {
direction: interfaces_1.MessageDirection.L1_TO_L2,
from: event.args.from,
to: event.args.to,
l1Token: event.args.l1Token,
l2Token: event.args.l2Token,
amount: event.args.amount,
data: event.args.extraData,
logIndex: event.logIndex,
blockNumber: event.blockNumber,
transactionHash: event.transactionHash,
};
})
.sort(function (a, b) {
return b.blockNumber - a.blockNumber;
})];
}
});
async getDepositsByAddress(address, opts) {
const events = await this.l1Bridge.queryFilter(this.l1Bridge.filters.ERC20DepositInitiated(undefined, undefined, address), opts === null || opts === void 0 ? void 0 : opts.fromBlock, opts === null || opts === void 0 ? void 0 : opts.toBlock);
return events
.filter((event) => {
return (!(0, core_utils_1.hexStringEquals)(event.args.l1Token, ethers_1.ethers.constants.AddressZero) &&
!(0, core_utils_1.hexStringEquals)(event.args.l2Token, contracts_1.predeploys.OVM_ETH));
})
.map((event) => {
return {
direction: interfaces_1.MessageDirection.L1_TO_L2,
from: event.args.from,
to: event.args.to,
l1Token: event.args.l1Token,
l2Token: event.args.l2Token,
amount: event.args.amount,
data: event.args.extraData,
logIndex: event.logIndex,
blockNumber: event.blockNumber,
transactionHash: event.transactionHash,
};
})
.sort((a, b) => {
return b.blockNumber - a.blockNumber;
});
};
StandardBridgeAdapter.prototype.getWithdrawalsByAddress = function (address, opts) {
return __awaiter(this, void 0, void 0, function () {
var events;
return __generator(this, function (_a) {
switch (_a.label) {
case 0: return [4, this.l2Bridge.queryFilter(this.l2Bridge.filters.WithdrawalInitiated(undefined, undefined, address), opts === null || opts === void 0 ? void 0 : opts.fromBlock, opts === null || opts === void 0 ? void 0 : opts.toBlock)];
case 1:
events = _a.sent();
return [2, events
.filter(function (event) {
return (!(0, core_utils_1.hexStringEquals)(event.args.l1Token, ethers_1.ethers.constants.AddressZero) &&
!(0, core_utils_1.hexStringEquals)(event.args.l2Token, contracts_1.predeploys.OVM_ETH));
})
.map(function (event) {
return {
direction: interfaces_1.MessageDirection.L2_TO_L1,
from: event.args.from,
to: event.args.to,
l1Token: event.args.l1Token,
l2Token: event.args.l2Token,
amount: event.args.amount,
data: event.args.extraData,
logIndex: event.logIndex,
blockNumber: event.blockNumber,
transactionHash: event.transactionHash,
};
})
.sort(function (a, b) {
return b.blockNumber - a.blockNumber;
})];
}
});
}
async getWithdrawalsByAddress(address, opts) {
const events = await this.l2Bridge.queryFilter(this.l2Bridge.filters.WithdrawalInitiated(undefined, undefined, address), opts === null || opts === void 0 ? void 0 : opts.fromBlock, opts === null || opts === void 0 ? void 0 : opts.toBlock);
return events
.filter((event) => {
return (!(0, core_utils_1.hexStringEquals)(event.args.l1Token, ethers_1.ethers.constants.AddressZero) &&
!(0, core_utils_1.hexStringEquals)(event.args.l2Token, contracts_1.predeploys.OVM_ETH));
})
.map((event) => {
return {
direction: interfaces_1.MessageDirection.L2_TO_L1,
from: event.args.from,
to: event.args.to,
l1Token: event.args.l1Token,
l2Token: event.args.l2Token,
amount: event.args.amount,
data: event.args.extraData,
logIndex: event.logIndex,
blockNumber: event.blockNumber,
transactionHash: event.transactionHash,
};
})
.sort((a, b) => {
return b.blockNumber - a.blockNumber;
});
};
StandardBridgeAdapter.prototype.supportsTokenPair = function (l1Token, l2Token) {
return __awaiter(this, void 0, void 0, function () {
var contract, remoteL1Token, remoteL2Bridge;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
contract = new ethers_1.Contract((0, utils_1.toAddress)(l2Token), OptimismMintableERC20_json_1.default.abi, this.messenger.l2Provider);
if ((0, core_utils_1.hexStringEquals)((0, utils_1.toAddress)(l1Token), ethers_1.ethers.constants.AddressZero) ||
(0, core_utils_1.hexStringEquals)((0, utils_1.toAddress)(l2Token), contracts_1.predeploys.OVM_ETH)) {
return [2, false];
}
return [4, contract.l1Token()];
case 1:
remoteL1Token = _a.sent();
if (!(0, core_utils_1.hexStringEquals)(remoteL1Token, (0, utils_1.toAddress)(l1Token))) {
return [2, false];
}
return [4, contract.l2Bridge()];
case 2:
remoteL2Bridge = _a.sent();
if (!(0, core_utils_1.hexStringEquals)(remoteL2Bridge, this.l2Bridge.address)) {
return [2, false];
}
return [2, true];
}
});
});
};
StandardBridgeAdapter.prototype.approval = function (l1Token, l2Token, signer) {
return __awaiter(this, void 0, void 0, function () {
var token, _a, _b;
return __generator(this, function (_c) {
switch (_c.label) {
case 0: return [4, this.supportsTokenPair(l1Token, l2Token)];
case 1:
if (!(_c.sent())) {
throw new Error("token pair not supported by bridge");
}
token = new ethers_1.Contract((0, utils_1.toAddress)(l1Token), OptimismMintableERC20_json_1.default.abi, this.messenger.l1Provider);
_b = (_a = token).allowance;
return [4, signer.getAddress()];
case 2: return [2, _b.apply(_a, [_c.sent(), this.l1Bridge.address])];
}
});
});
};
StandardBridgeAdapter.prototype.approve = function (l1Token, l2Token, amount, signer, opts) {
return __awaiter(this, void 0, void 0, function () {
var _a, _b;
return __generator(this, function (_c) {
switch (_c.label) {
case 0:
_b = (_a = signer).sendTransaction;
return [4, this.populateTransaction.approve(l1Token, l2Token, amount, opts)];
case 1: return [2, _b.apply(_a, [_c.sent()])];
}
});
});
};
StandardBridgeAdapter.prototype.deposit = function (l1Token, l2Token, amount, signer, opts) {
return __awaiter(this, void 0, void 0, function () {
var _a, _b;
return __generator(this, function (_c) {
switch (_c.label) {
case 0:
_b = (_a = signer).sendTransaction;
return [4, this.populateTransaction.deposit(l1Token, l2Token, amount, opts)];
case 1: return [2, _b.apply(_a, [_c.sent()])];
}
});
});
};
StandardBridgeAdapter.prototype.withdraw = function (l1Token, l2Token, amount, signer, opts) {
return __awaiter(this, void 0, void 0, function () {
var _a, _b;
return __generator(this, function (_c) {
switch (_c.label) {
case 0:
_b = (_a = signer).sendTransaction;
return [4, this.populateTransaction.withdraw(l1Token, l2Token, amount, opts)];
case 1: return [2, _b.apply(_a, [_c.sent()])];
}
});
});
};
return StandardBridgeAdapter;
}());
}
async supportsTokenPair(l1Token, l2Token) {
const contract = new ethers_1.Contract((0, utils_1.toAddress)(l2Token), OptimismMintableERC20_json_1.default.abi, this.messenger.l2Provider);
if ((0, core_utils_1.hexStringEquals)((0, utils_1.toAddress)(l1Token), ethers_1.ethers.constants.AddressZero) ||
(0, core_utils_1.hexStringEquals)((0, utils_1.toAddress)(l2Token), contracts_1.predeploys.OVM_ETH)) {
return false;
}
const remoteL1Token = await contract.l1Token();
if (!(0, core_utils_1.hexStringEquals)(remoteL1Token, (0, utils_1.toAddress)(l1Token))) {
return false;
}
const remoteL2Bridge = await contract.l2Bridge();
if (!(0, core_utils_1.hexStringEquals)(remoteL2Bridge, this.l2Bridge.address)) {
return false;
}
return true;
}
async approval(l1Token, l2Token, signer) {
if (!(await this.supportsTokenPair(l1Token, l2Token))) {
throw new Error(`token pair not supported by bridge`);
}
const token = new ethers_1.Contract((0, utils_1.toAddress)(l1Token), OptimismMintableERC20_json_1.default.abi, this.messenger.l1Provider);
return token.allowance(await signer.getAddress(), this.l1Bridge.address);
}
async approve(l1Token, l2Token, amount, signer, opts) {
return signer.sendTransaction(await this.populateTransaction.approve(l1Token, l2Token, amount, opts));
}
async deposit(l1Token, l2Token, amount, signer, opts) {
return signer.sendTransaction(await this.populateTransaction.deposit(l1Token, l2Token, amount, opts));
}
async withdraw(l1Token, l2Token, amount, signer, opts) {
return signer.sendTransaction(await this.populateTransaction.withdraw(l1Token, l2Token, amount, opts));
}
}
exports.StandardBridgeAdapter = StandardBridgeAdapter;

307

dist/l2-provider.js
"use strict";
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 __generator = (this && this.__generator) || function (thisArg, body) {
var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
function verb(n) { return function (v) { return step([n, v]); }; }
function step(op) {
if (f) throw new TypeError("Generator is already executing.");
while (g && (g = 0, op[0] && (_ = 0)), _) try {
if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
if (y = 0, t) op = [op[0] & 2, t.value];
switch (op[0]) {
case 0: case 1: t = op; break;
case 4: _.label++; return { value: op[1], done: false };
case 5: _.label++; y = op[1]; op = [0]; continue;
case 7: op = _.ops.pop(); _.trys.pop(); continue;
default:
if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
if (t[2]) _.ops.pop();
_.trys.pop(); continue;
}
op = body.call(thisArg, _);
} catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
}
};
var __importDefault = (this && this.__importDefault) || function (mod) {

@@ -43,156 +7,101 @@ return (mod && mod.__esModule) ? mod : { "default": mod };

exports.asL2Provider = exports.isL2Provider = exports.estimateTotalGasCost = exports.estimateL2GasCost = exports.estimateL1GasCost = exports.estimateL1Gas = exports.getL1GasPrice = void 0;
var contracts_1 = require("@eth-optimism/contracts");
var transactions_1 = require("@ethersproject/transactions");
var ethers_1 = require("ethers");
var cloneDeep_1 = __importDefault(require("lodash/cloneDeep"));
var utils_1 = require("./utils");
var assert_1 = require("./utils/assert");
var getNonceForTx = function (provider, tx) { return __awaiter(void 0, void 0, void 0, function () {
return __generator(this, function (_a) {
if (tx.nonce !== undefined) {
return [2, (0, utils_1.toNumber)(tx.nonce)];
}
else if (tx.from !== undefined) {
return [2, (0, utils_1.toProvider)(provider).getTransactionCount(tx.from)];
}
else {
return [2, 0xffffffff];
}
return [2];
});
}); };
var connectGasPriceOracle = function (provider) {
const contracts_1 = require("@eth-optimism/contracts");
const transactions_1 = require("@ethersproject/transactions");
const ethers_1 = require("ethers");
const cloneDeep_1 = __importDefault(require("lodash/cloneDeep"));
const utils_1 = require("./utils");
const assert_1 = require("./utils/assert");
const getNonceForTx = async (provider, tx) => {
if (tx.nonce !== undefined) {
return (0, utils_1.toNumber)(tx.nonce);
}
else if (tx.from !== undefined) {
return (0, utils_1.toProvider)(provider).getTransactionCount(tx.from);
}
else {
return 0xffffffff;
}
};
const connectGasPriceOracle = (provider) => {
return new ethers_1.Contract(contracts_1.predeploys.OVM_GasPriceOracle, (0, contracts_1.getContractInterface)('OVM_GasPriceOracle'), (0, utils_1.toProvider)(provider));
};
var getL1GasPrice = function (l2Provider) { return __awaiter(void 0, void 0, void 0, function () {
var gpo;
return __generator(this, function (_a) {
gpo = connectGasPriceOracle(l2Provider);
return [2, gpo.l1BaseFee()];
});
}); };
const getL1GasPrice = async (l2Provider) => {
const gpo = connectGasPriceOracle(l2Provider);
return gpo.l1BaseFee();
};
exports.getL1GasPrice = getL1GasPrice;
var estimateL1Gas = function (l2Provider, tx) { return __awaiter(void 0, void 0, void 0, function () {
var gpo, _a, _b, _c, _d;
var _e;
return __generator(this, function (_f) {
switch (_f.label) {
case 0:
gpo = connectGasPriceOracle(l2Provider);
_b = (_a = gpo).getL1GasUsed;
_c = transactions_1.serialize;
_e = {
to: tx.to,
gasLimit: tx.gasLimit,
gasPrice: tx.gasPrice,
maxFeePerGas: tx.maxFeePerGas,
maxPriorityFeePerGas: tx.maxPriorityFeePerGas,
data: tx.data,
value: tx.value,
chainId: tx.chainId,
type: tx.type,
accessList: tx.accessList
};
if (!tx.nonce) return [3, 1];
_d = ethers_1.BigNumber.from(tx.nonce).toNumber();
return [3, 3];
case 1: return [4, getNonceForTx(l2Provider, tx)];
case 2:
_d = _f.sent();
_f.label = 3;
case 3: return [2, _b.apply(_a, [_c.apply(void 0, [(_e.nonce = _d,
_e)])])];
}
});
}); };
const estimateL1Gas = async (l2Provider, tx) => {
const gpo = connectGasPriceOracle(l2Provider);
return gpo.getL1GasUsed((0, transactions_1.serialize)({
to: tx.to,
gasLimit: tx.gasLimit,
gasPrice: tx.gasPrice,
maxFeePerGas: tx.maxFeePerGas,
maxPriorityFeePerGas: tx.maxPriorityFeePerGas,
data: tx.data,
value: tx.value,
chainId: tx.chainId,
type: tx.type,
accessList: tx.accessList,
nonce: tx.nonce
? ethers_1.BigNumber.from(tx.nonce).toNumber()
: await getNonceForTx(l2Provider, tx),
}));
};
exports.estimateL1Gas = estimateL1Gas;
var estimateL1GasCost = function (l2Provider, tx) { return __awaiter(void 0, void 0, void 0, function () {
var gpo, _a, _b, _c, _d;
var _e;
return __generator(this, function (_f) {
switch (_f.label) {
case 0:
gpo = connectGasPriceOracle(l2Provider);
_b = (_a = gpo).getL1Fee;
_c = transactions_1.serialize;
_e = {
to: tx.to,
gasLimit: tx.gasLimit,
gasPrice: tx.gasPrice,
maxFeePerGas: tx.maxFeePerGas,
maxPriorityFeePerGas: tx.maxPriorityFeePerGas,
data: tx.data,
value: tx.value,
chainId: tx.chainId,
type: tx.type,
accessList: tx.accessList
};
if (!tx.nonce) return [3, 1];
_d = ethers_1.BigNumber.from(tx.nonce).toNumber();
return [3, 3];
case 1: return [4, getNonceForTx(l2Provider, tx)];
case 2:
_d = _f.sent();
_f.label = 3;
case 3: return [2, _b.apply(_a, [_c.apply(void 0, [(_e.nonce = _d,
_e)])])];
}
});
}); };
const estimateL1GasCost = async (l2Provider, tx) => {
const gpo = connectGasPriceOracle(l2Provider);
return gpo.getL1Fee((0, transactions_1.serialize)({
to: tx.to,
gasLimit: tx.gasLimit,
gasPrice: tx.gasPrice,
maxFeePerGas: tx.maxFeePerGas,
maxPriorityFeePerGas: tx.maxPriorityFeePerGas,
data: tx.data,
value: tx.value,
chainId: tx.chainId,
type: tx.type,
accessList: tx.accessList,
nonce: tx.nonce
? ethers_1.BigNumber.from(tx.nonce).toNumber()
: await getNonceForTx(l2Provider, tx),
}));
};
exports.estimateL1GasCost = estimateL1GasCost;
var estimateL2GasCost = function (l2Provider, tx) { return __awaiter(void 0, void 0, void 0, function () {
var parsed, l2GasPrice, l2GasCost;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
parsed = (0, utils_1.toProvider)(l2Provider);
return [4, parsed.getGasPrice()];
case 1:
l2GasPrice = _a.sent();
return [4, parsed.estimateGas(tx)];
case 2:
l2GasCost = _a.sent();
return [2, l2GasPrice.mul(l2GasCost)];
}
});
}); };
const estimateL2GasCost = async (l2Provider, tx) => {
const parsed = (0, utils_1.toProvider)(l2Provider);
const l2GasPrice = await parsed.getGasPrice();
const l2GasCost = await parsed.estimateGas(tx);
return l2GasPrice.mul(l2GasCost);
};
exports.estimateL2GasCost = estimateL2GasCost;
var estimateTotalGasCost = function (l2Provider, tx) { return __awaiter(void 0, void 0, void 0, function () {
var l1GasCost, l2GasCost;
return __generator(this, function (_a) {
switch (_a.label) {
case 0: return [4, (0, exports.estimateL1GasCost)(l2Provider, tx)];
case 1:
l1GasCost = _a.sent();
return [4, (0, exports.estimateL2GasCost)(l2Provider, tx)];
case 2:
l2GasCost = _a.sent();
return [2, l1GasCost.add(l2GasCost)];
}
});
}); };
const estimateTotalGasCost = async (l2Provider, tx) => {
const l1GasCost = await (0, exports.estimateL1GasCost)(l2Provider, tx);
const l2GasCost = await (0, exports.estimateL2GasCost)(l2Provider, tx);
return l1GasCost.add(l2GasCost);
};
exports.estimateTotalGasCost = estimateTotalGasCost;
var isL2Provider = function (provider) {
const isL2Provider = (provider) => {
return Boolean(provider._isL2Provider);
};
exports.isL2Provider = isL2Provider;
var asL2Provider = function (provider) {
const asL2Provider = (provider) => {
if ((0, exports.isL2Provider)(provider)) {
return provider;
}
var l2Provider = (0, cloneDeep_1.default)(provider);
var formatter = l2Provider.formatter;
(0, assert_1.assert)(formatter, "provider.formatter must be defined");
var ogBlockFormatter = formatter.block.bind(formatter);
formatter.block = function (block) {
var parsed = ogBlockFormatter(block);
const l2Provider = (0, cloneDeep_1.default)(provider);
const formatter = l2Provider.formatter;
(0, assert_1.assert)(formatter, `provider.formatter must be defined`);
const ogBlockFormatter = formatter.block.bind(formatter);
formatter.block = (block) => {
const parsed = ogBlockFormatter(block);
parsed.stateRoot = block.stateRoot;
return parsed;
};
var ogBlockWithTxFormatter = formatter.blockWithTransactions.bind(formatter);
formatter.blockWithTransactions = function (block) {
var parsed = ogBlockWithTxFormatter(block);
const ogBlockWithTxFormatter = formatter.blockWithTransactions.bind(formatter);
formatter.blockWithTransactions = (block) => {
const parsed = ogBlockWithTxFormatter(block);
parsed.stateRoot = block.stateRoot;
parsed.transactions = parsed.transactions.map(function (tx, idx) {
var ogTx = block.transactions[idx];
parsed.transactions = parsed.transactions.map((tx, idx) => {
const ogTx = block.transactions[idx];
tx.l1BlockNumber = ogTx.l1BlockNumber

@@ -211,5 +120,5 @@ ? (0, utils_1.toNumber)(ogTx.l1BlockNumber)

};
var ogTxResponseFormatter = formatter.transactionResponse.bind(formatter);
formatter.transactionResponse = function (tx) {
var parsed = ogTxResponseFormatter(tx);
const ogTxResponseFormatter = formatter.transactionResponse.bind(formatter);
formatter.transactionResponse = (tx) => {
const parsed = ogTxResponseFormatter(tx);
parsed.txType = tx.txType;

@@ -224,5 +133,5 @@ parsed.queueOrigin = tx.queueOrigin;

};
var ogReceiptFormatter = formatter.receipt.bind(formatter);
formatter.receipt = function (receipt) {
var parsed = ogReceiptFormatter(receipt);
const ogReceiptFormatter = formatter.receipt.bind(formatter);
formatter.receipt = (receipt) => {
const parsed = ogReceiptFormatter(receipt);
parsed.l1GasPrice = (0, utils_1.toBigNumber)(receipt.l1GasPrice);

@@ -234,27 +143,17 @@ parsed.l1GasUsed = (0, utils_1.toBigNumber)(receipt.l1GasUsed);

};
l2Provider.getL1GasPrice = function () { return __awaiter(void 0, void 0, void 0, function () {
return __generator(this, function (_a) {
return [2, (0, exports.getL1GasPrice)(l2Provider)];
});
}); };
l2Provider.estimateL1Gas = function (tx) { return __awaiter(void 0, void 0, void 0, function () {
return __generator(this, function (_a) {
return [2, (0, exports.estimateL1Gas)(l2Provider, tx)];
});
}); };
l2Provider.estimateL1GasCost = function (tx) { return __awaiter(void 0, void 0, void 0, function () {
return __generator(this, function (_a) {
return [2, (0, exports.estimateL1GasCost)(l2Provider, tx)];
});
}); };
l2Provider.estimateL2GasCost = function (tx) { return __awaiter(void 0, void 0, void 0, function () {
return __generator(this, function (_a) {
return [2, (0, exports.estimateL2GasCost)(l2Provider, tx)];
});
}); };
l2Provider.estimateTotalGasCost = function (tx) { return __awaiter(void 0, void 0, void 0, function () {
return __generator(this, function (_a) {
return [2, (0, exports.estimateTotalGasCost)(l2Provider, tx)];
});
}); };
l2Provider.getL1GasPrice = async () => {
return (0, exports.getL1GasPrice)(l2Provider);
};
l2Provider.estimateL1Gas = async (tx) => {
return (0, exports.estimateL1Gas)(l2Provider, tx);
};
l2Provider.estimateL1GasCost = async (tx) => {
return (0, exports.estimateL1GasCost)(l2Provider, tx);
};
l2Provider.estimateL2GasCost = async (tx) => {
return (0, exports.estimateL2GasCost)(l2Provider, tx);
};
l2Provider.estimateTotalGasCost = async (tx) => {
return (0, exports.estimateTotalGasCost)(l2Provider, tx);
};
l2Provider._isL2Provider = true;

@@ -261,0 +160,0 @@ return l2Provider;

2

dist/utils/assert.js
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.assert = void 0;
var assert = function (condition, message) {
const assert = (condition, message) => {
if (!condition) {

@@ -6,0 +6,0 @@ throw new Error(message);

109

dist/utils/chain-constants.js
"use strict";
var _a, _b, _c, _d;
Object.defineProperty(exports, "__esModule", { value: true });
exports.BRIDGE_ADAPTER_DATA = exports.CONTRACT_ADDRESSES = exports.IGNORABLE_CONTRACTS = exports.DEFAULT_L2_CONTRACT_ADDRESSES = exports.CHAIN_BLOCK_TIMES = exports.DEPOSIT_CONFIRMATION_BLOCKS = void 0;
var core_utils_1 = require("@eth-optimism/core-utils");
var ethers_1 = require("ethers");
var adapters_1 = require("../adapters");
var interfaces_1 = require("../interfaces");
var portalAddresses = {
const core_utils_1 = require("@eth-optimism/core-utils");
const ethers_1 = require("ethers");
const adapters_1 = require("../adapters");
const interfaces_1 = require("../interfaces");
const portalAddresses = {
mainnet: '0xbEb5Fc579115071764c7423A4f12eDde41f106Ed',

@@ -14,3 +13,3 @@ goerli: '0x5b47E1A08Ea6d985D6649300584e6722Ec4B1383',

};
var l2OutputOracleAddresses = {
const l2OutputOracleAddresses = {
mainnet: '0xdfe97868233d1aa22e815a266982f2cf17685a27',

@@ -20,3 +19,3 @@ goerli: '0xE6Dfba0953616Bacab0c9A8ecb3a9BBa77FC15c0',

};
var addressManagerAddresses = {
const addressManagerAddresses = {
mainnet: '0xdE1FCfB0851916CA5101820A69b13a4E276bd81F',

@@ -26,3 +25,3 @@ goerli: '0xa6f73589243a6A7a9023b1Fa0651b1d89c177111',

};
var l1StandardBridgeAddresses = {
const l1StandardBridgeAddresses = {
mainnet: '0x99C9fc46f92E8a1c0deC1b1747d010903E884bE1',

@@ -32,3 +31,3 @@ goerli: '0x636Af16bf2f682dD3109e60102b8E1A089FedAa8',

};
var l1CrossDomainMessengerAddresses = {
const l1CrossDomainMessengerAddresses = {
mainnet: '0x25ace71c97B33Cc4729CF772ae268934F7ab5fA1',

@@ -38,3 +37,3 @@ goerli: '0x5086d1eEF304eb5284A0f6720f79403b4e9bE294',

};
var disputeGameFactoryAddresses = {
const disputeGameFactoryAddresses = {
mainnet: '0xe5965Ab5962eDc7477C8520243A95517CD252fA9',

@@ -44,3 +43,3 @@ goerli: ethers_1.ethers.constants.AddressZero,

};
var stateCommitmentChainAddresses = {
const stateCommitmentChainAddresses = {
mainnet: '0xBe5dAb4A2e9cd0F27300dB4aB94BeE3A233AEB19',

@@ -50,3 +49,3 @@ goerli: '0x9c945aC97Baf48cB784AbBB61399beB71aF7A378',

};
var canonicalTransactionChainAddresses = {
const canonicalTransactionChainAddresses = {
mainnet: '0x5E4e65926BA27467555EB562121fac00D24E9dD2',

@@ -56,24 +55,24 @@ goerli: '0x607F755149cFEB3a14E1Dc3A4E2450Cde7dfb04D',

};
exports.DEPOSIT_CONFIRMATION_BLOCKS = (_a = {},
_a[interfaces_1.L2ChainID.OPTIMISM] = 50,
_a[interfaces_1.L2ChainID.OPTIMISM_GOERLI] = 12,
_a[interfaces_1.L2ChainID.OPTIMISM_SEPOLIA] = 12,
_a[interfaces_1.L2ChainID.OPTIMISM_HARDHAT_LOCAL] = 2,
_a[interfaces_1.L2ChainID.OPTIMISM_HARDHAT_DEVNET] = 2,
_a[interfaces_1.L2ChainID.OPTIMISM_BEDROCK_ALPHA_TESTNET] = 12,
_a[interfaces_1.L2ChainID.BASE_GOERLI] = 25,
_a[interfaces_1.L2ChainID.BASE_SEPOLIA] = 25,
_a[interfaces_1.L2ChainID.BASE_MAINNET] = 10,
_a[interfaces_1.L2ChainID.ZORA_GOERLI] = 12,
_a[interfaces_1.L2ChainID.ZORA_MAINNET] = 50,
_a[interfaces_1.L2ChainID.MODE_SEPOLIA] = 25,
_a[interfaces_1.L2ChainID.MODE_MAINNET] = 50,
_a);
exports.CHAIN_BLOCK_TIMES = (_b = {},
_b[interfaces_1.L1ChainID.MAINNET] = 13,
_b[interfaces_1.L1ChainID.GOERLI] = 15,
_b[interfaces_1.L1ChainID.SEPOLIA] = 15,
_b[interfaces_1.L1ChainID.HARDHAT_LOCAL] = 1,
_b[interfaces_1.L1ChainID.BEDROCK_LOCAL_DEVNET] = 15,
_b);
exports.DEPOSIT_CONFIRMATION_BLOCKS = {
[interfaces_1.L2ChainID.OPTIMISM]: 50,
[interfaces_1.L2ChainID.OPTIMISM_GOERLI]: 12,
[interfaces_1.L2ChainID.OPTIMISM_SEPOLIA]: 12,
[interfaces_1.L2ChainID.OPTIMISM_HARDHAT_LOCAL]: 2,
[interfaces_1.L2ChainID.OPTIMISM_HARDHAT_DEVNET]: 2,
[interfaces_1.L2ChainID.OPTIMISM_BEDROCK_ALPHA_TESTNET]: 12,
[interfaces_1.L2ChainID.BASE_GOERLI]: 25,
[interfaces_1.L2ChainID.BASE_SEPOLIA]: 25,
[interfaces_1.L2ChainID.BASE_MAINNET]: 10,
[interfaces_1.L2ChainID.ZORA_GOERLI]: 12,
[interfaces_1.L2ChainID.ZORA_MAINNET]: 50,
[interfaces_1.L2ChainID.MODE_SEPOLIA]: 25,
[interfaces_1.L2ChainID.MODE_MAINNET]: 50,
};
exports.CHAIN_BLOCK_TIMES = {
[interfaces_1.L1ChainID.MAINNET]: 13,
[interfaces_1.L1ChainID.GOERLI]: 15,
[interfaces_1.L1ChainID.SEPOLIA]: 15,
[interfaces_1.L1ChainID.HARDHAT_LOCAL]: 1,
[interfaces_1.L1ChainID.BEDROCK_LOCAL_DEVNET]: 15,
};
exports.DEFAULT_L2_CONTRACT_ADDRESSES = {

@@ -92,3 +91,3 @@ L2CrossDomainMessenger: core_utils_1.predeploys.L2CrossDomainMessenger,

};
var getL1ContractsByNetworkName = function (network) {
const getL1ContractsByNetworkName = (network) => {
return {

@@ -108,16 +107,16 @@ AddressManager: addressManagerAddresses[network],

exports.IGNORABLE_CONTRACTS = ['OptimismPortal2', 'DisputeGameFactory'];
exports.CONTRACT_ADDRESSES = (_c = {},
_c[interfaces_1.L2ChainID.OPTIMISM] = {
exports.CONTRACT_ADDRESSES = {
[interfaces_1.L2ChainID.OPTIMISM]: {
l1: getL1ContractsByNetworkName('mainnet'),
l2: exports.DEFAULT_L2_CONTRACT_ADDRESSES,
},
_c[interfaces_1.L2ChainID.OPTIMISM_GOERLI] = {
[interfaces_1.L2ChainID.OPTIMISM_GOERLI]: {
l1: getL1ContractsByNetworkName('goerli'),
l2: exports.DEFAULT_L2_CONTRACT_ADDRESSES,
},
_c[interfaces_1.L2ChainID.OPTIMISM_SEPOLIA] = {
[interfaces_1.L2ChainID.OPTIMISM_SEPOLIA]: {
l1: getL1ContractsByNetworkName('sepolia'),
l2: exports.DEFAULT_L2_CONTRACT_ADDRESSES,
},
_c[interfaces_1.L2ChainID.OPTIMISM_HARDHAT_LOCAL] = {
[interfaces_1.L2ChainID.OPTIMISM_HARDHAT_LOCAL]: {
l1: {

@@ -137,3 +136,3 @@ AddressManager: '0x5FbDB2315678afecb367f032d93F642f64180aa3',

},
_c[interfaces_1.L2ChainID.OPTIMISM_HARDHAT_DEVNET] = {
[interfaces_1.L2ChainID.OPTIMISM_HARDHAT_DEVNET]: {
l1: {

@@ -153,3 +152,3 @@ AddressManager: '0x5FbDB2315678afecb367f032d93F642f64180aa3',

},
_c[interfaces_1.L2ChainID.OPTIMISM_BEDROCK_ALPHA_TESTNET] = {
[interfaces_1.L2ChainID.OPTIMISM_BEDROCK_ALPHA_TESTNET]: {
l1: {

@@ -169,3 +168,3 @@ AddressManager: '0xb4e08DcE1F323608229265c9d4125E22a4B9dbAF',

},
_c[interfaces_1.L2ChainID.BASE_GOERLI] = {
[interfaces_1.L2ChainID.BASE_GOERLI]: {
l1: {

@@ -185,3 +184,3 @@ AddressManager: '0x4Cf6b56b14c6CFcB72A75611080514F94624c54e',

},
_c[interfaces_1.L2ChainID.BASE_SEPOLIA] = {
[interfaces_1.L2ChainID.BASE_SEPOLIA]: {
l1: {

@@ -201,3 +200,3 @@ AddressManager: '0x709c2B8ef4A9feFc629A8a2C1AF424Dc5BD6ad1B',

},
_c[interfaces_1.L2ChainID.BASE_MAINNET] = {
[interfaces_1.L2ChainID.BASE_MAINNET]: {
l1: {

@@ -217,3 +216,3 @@ AddressManager: '0x8EfB6B5c4767B09Dc9AA6Af4eAA89F749522BaE2',

},
_c[interfaces_1.L2ChainID.ZORA_GOERLI] = {
[interfaces_1.L2ChainID.ZORA_GOERLI]: {
l1: {

@@ -233,3 +232,3 @@ AddressManager: '0x54f4676203dEDA6C08E0D40557A119c602bFA246',

},
_c[interfaces_1.L2ChainID.ZORA_MAINNET] = {
[interfaces_1.L2ChainID.ZORA_MAINNET]: {
l1: {

@@ -249,3 +248,3 @@ AddressManager: '0xEF8115F2733fb2033a7c756402Fc1deaa56550Ef',

},
_c[interfaces_1.L2ChainID.MODE_SEPOLIA] = {
[interfaces_1.L2ChainID.MODE_SEPOLIA]: {
l1: {

@@ -265,3 +264,3 @@ AddressManager: '0x83D45725d6562d8CD717673D6bb4c67C07dC1905',

},
_c[interfaces_1.L2ChainID.MODE_MAINNET] = {
[interfaces_1.L2ChainID.MODE_MAINNET]: {
l1: {

@@ -281,5 +280,5 @@ AddressManager: '0x50eF494573f28Cad6B64C31b7a00Cdaa48306e15',

},
_c);
exports.BRIDGE_ADAPTER_DATA = (_d = {},
_d[interfaces_1.L2ChainID.OPTIMISM] = {
};
exports.BRIDGE_ADAPTER_DATA = {
[interfaces_1.L2ChainID.OPTIMISM]: {
wstETH: {

@@ -306,3 +305,3 @@ Adapter: adapters_1.DAIBridgeAdapter,

},
_d[interfaces_1.L2ChainID.OPTIMISM_GOERLI] = {
[interfaces_1.L2ChainID.OPTIMISM_GOERLI]: {
DAI: {

@@ -319,2 +318,2 @@ Adapter: adapters_1.DAIBridgeAdapter,

},
_d);
};

24

dist/utils/coercion.js
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.toAddress = exports.toNumber = exports.toBigNumber = exports.toTransactionHash = exports.toJsonRpcProvider = exports.toProvider = exports.toSignerOrProvider = void 0;
var abstract_provider_1 = require("@ethersproject/abstract-provider");
var abstract_signer_1 = require("@ethersproject/abstract-signer");
var ethers_1 = require("ethers");
var assert_1 = require("./assert");
var toSignerOrProvider = function (signerOrProvider) {
const abstract_provider_1 = require("@ethersproject/abstract-provider");
const abstract_signer_1 = require("@ethersproject/abstract-signer");
const ethers_1 = require("ethers");
const assert_1 = require("./assert");
const toSignerOrProvider = (signerOrProvider) => {
if (typeof signerOrProvider === 'string') {

@@ -23,3 +23,3 @@ return new ethers_1.ethers.providers.JsonRpcProvider(signerOrProvider);

exports.toSignerOrProvider = toSignerOrProvider;
var toProvider = function (provider) {
const toProvider = (provider) => {
if (typeof provider === 'string') {

@@ -36,4 +36,4 @@ return new ethers_1.ethers.providers.JsonRpcProvider(provider);

exports.toProvider = toProvider;
var toJsonRpcProvider = function (provider) {
var coerced = (0, exports.toProvider)(provider);
const toJsonRpcProvider = (provider) => {
const coerced = (0, exports.toProvider)(provider);
if ('send' in coerced) {

@@ -47,3 +47,3 @@ return coerced;

exports.toJsonRpcProvider = toJsonRpcProvider;
var toTransactionHash = function (transaction) {
const toTransactionHash = (transaction) => {
if (typeof transaction === 'string') {

@@ -64,11 +64,11 @@ (0, assert_1.assert)(ethers_1.ethers.utils.isHexString(transaction, 32), 'Invalid transaction hash');

exports.toTransactionHash = toTransactionHash;
var toBigNumber = function (num) {
const toBigNumber = (num) => {
return ethers_1.ethers.BigNumber.from(num);
};
exports.toBigNumber = toBigNumber;
var toNumber = function (num) {
const toNumber = (num) => {
return (0, exports.toBigNumber)(num).toNumber();
};
exports.toNumber = toNumber;
var toAddress = function (addr) {
const toAddress = (addr) => {
if (typeof addr === 'string') {

@@ -75,0 +75,0 @@ (0, assert_1.assert)(ethers_1.ethers.utils.isAddress(addr), 'Invalid address');

98

dist/utils/contracts.js
"use strict";
var __assign = (this && this.__assign) || function () {
__assign = Object.assign || function(t) {
for (var s, i = 1, n = arguments.length; i < n; i++) {
s = arguments[i];
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
t[p] = s[p];
}
return t;
};
return __assign.apply(this, arguments);
};
var __importDefault = (this && this.__importDefault) || function (mod) {

@@ -18,25 +7,25 @@ return (mod && mod.__esModule) ? mod : { "default": mod };

exports.getBridgeAdapters = exports.getAllOEContracts = exports.getOEContract = exports.getContractInterfaceBedrock = void 0;
var contracts_1 = require("@eth-optimism/contracts");
var ethers_1 = require("ethers");
var adapters_1 = require("../adapters");
var DisputeGameFactory_json_1 = __importDefault(require("../forge-artifacts/DisputeGameFactory.json"));
var FaultDisputeGame_json_1 = __importDefault(require("../forge-artifacts/FaultDisputeGame.json"));
var GasPriceOracle_json_1 = __importDefault(require("../forge-artifacts/GasPriceOracle.json"));
var L1Block_json_1 = __importDefault(require("../forge-artifacts/L1Block.json"));
var L1CrossDomainMessenger_json_1 = __importDefault(require("../forge-artifacts/L1CrossDomainMessenger.json"));
var L1ERC721Bridge_json_1 = __importDefault(require("../forge-artifacts/L1ERC721Bridge.json"));
var L1StandardBridge_json_1 = __importDefault(require("../forge-artifacts/L1StandardBridge.json"));
var L2CrossDomainMessenger_json_1 = __importDefault(require("../forge-artifacts/L2CrossDomainMessenger.json"));
var L2ERC721Bridge_json_1 = __importDefault(require("../forge-artifacts/L2ERC721Bridge.json"));
var L2OutputOracle_json_1 = __importDefault(require("../forge-artifacts/L2OutputOracle.json"));
var L2StandardBridge_json_1 = __importDefault(require("../forge-artifacts/L2StandardBridge.json"));
var L2ToL1MessagePasser_json_1 = __importDefault(require("../forge-artifacts/L2ToL1MessagePasser.json"));
var OptimismMintableERC20_json_1 = __importDefault(require("../forge-artifacts/OptimismMintableERC20.json"));
var OptimismMintableERC20Factory_json_1 = __importDefault(require("../forge-artifacts/OptimismMintableERC20Factory.json"));
var OptimismPortal_json_1 = __importDefault(require("../forge-artifacts/OptimismPortal.json"));
var OptimismPortal2_json_1 = __importDefault(require("../forge-artifacts/OptimismPortal2.json"));
var ProxyAdmin_json_1 = __importDefault(require("../forge-artifacts/ProxyAdmin.json"));
var chain_constants_1 = require("./chain-constants");
var coercion_1 = require("./coercion");
var NAME_REMAPPING = {
const contracts_1 = require("@eth-optimism/contracts");
const ethers_1 = require("ethers");
const adapters_1 = require("../adapters");
const DisputeGameFactory_json_1 = __importDefault(require("../forge-artifacts/DisputeGameFactory.json"));
const FaultDisputeGame_json_1 = __importDefault(require("../forge-artifacts/FaultDisputeGame.json"));
const GasPriceOracle_json_1 = __importDefault(require("../forge-artifacts/GasPriceOracle.json"));
const L1Block_json_1 = __importDefault(require("../forge-artifacts/L1Block.json"));
const L1CrossDomainMessenger_json_1 = __importDefault(require("../forge-artifacts/L1CrossDomainMessenger.json"));
const L1ERC721Bridge_json_1 = __importDefault(require("../forge-artifacts/L1ERC721Bridge.json"));
const L1StandardBridge_json_1 = __importDefault(require("../forge-artifacts/L1StandardBridge.json"));
const L2CrossDomainMessenger_json_1 = __importDefault(require("../forge-artifacts/L2CrossDomainMessenger.json"));
const L2ERC721Bridge_json_1 = __importDefault(require("../forge-artifacts/L2ERC721Bridge.json"));
const L2OutputOracle_json_1 = __importDefault(require("../forge-artifacts/L2OutputOracle.json"));
const L2StandardBridge_json_1 = __importDefault(require("../forge-artifacts/L2StandardBridge.json"));
const L2ToL1MessagePasser_json_1 = __importDefault(require("../forge-artifacts/L2ToL1MessagePasser.json"));
const OptimismMintableERC20_json_1 = __importDefault(require("../forge-artifacts/OptimismMintableERC20.json"));
const OptimismMintableERC20Factory_json_1 = __importDefault(require("../forge-artifacts/OptimismMintableERC20Factory.json"));
const OptimismPortal_json_1 = __importDefault(require("../forge-artifacts/OptimismPortal.json"));
const OptimismPortal2_json_1 = __importDefault(require("../forge-artifacts/OptimismPortal2.json"));
const ProxyAdmin_json_1 = __importDefault(require("../forge-artifacts/ProxyAdmin.json"));
const chain_constants_1 = require("./chain-constants");
const coercion_1 = require("./coercion");
const NAME_REMAPPING = {
AddressManager: 'Lib_AddressManager',

@@ -47,4 +36,4 @@ OVM_L1BlockNumber: 'iOVM_L1BlockNumber',

};
var getContractInterfaceBedrock = function (name) {
var artifact = '';
const getContractInterfaceBedrock = (name) => {
let artifact = '';
switch (name) {

@@ -110,5 +99,4 @@ case 'Lib_AddressManager':

exports.getContractInterfaceBedrock = getContractInterfaceBedrock;
var getOEContract = function (contractName, l2ChainId, opts) {
if (opts === void 0) { opts = {}; }
var addresses = chain_constants_1.CONTRACT_ADDRESSES[l2ChainId];
const getOEContract = (contractName, l2ChainId, opts = {}) => {
const addresses = chain_constants_1.CONTRACT_ADDRESSES[l2ChainId];
if (addresses === undefined && opts.address === undefined) {

@@ -119,7 +107,7 @@ if (chain_constants_1.IGNORABLE_CONTRACTS.includes(contractName)) {

else {
throw new Error("cannot get contract ".concat(contractName, " for unknown L2 chain ID ").concat(l2ChainId, ", you must provide an address"));
throw new Error(`cannot get contract ${contractName} for unknown L2 chain ID ${l2ChainId}, you must provide an address`);
}
}
var name = NAME_REMAPPING[contractName] || contractName;
var iface;
const name = NAME_REMAPPING[contractName] || contractName;
let iface;
try {

@@ -134,6 +122,5 @@ iface = (0, exports.getContractInterfaceBedrock)(name);

exports.getOEContract = getOEContract;
var getAllOEContracts = function (l2ChainId, opts) {
const getAllOEContracts = (l2ChainId, opts = {}) => {
var _a, _b, _c, _d;
if (opts === void 0) { opts = {}; }
var addresses = chain_constants_1.CONTRACT_ADDRESSES[l2ChainId] || {
const addresses = chain_constants_1.CONTRACT_ADDRESSES[l2ChainId] || {
l1: {

@@ -153,5 +140,4 @@ AddressManager: undefined,

};
var l1Contracts = {};
for (var _i = 0, _e = Object.entries(addresses.l1); _i < _e.length; _i++) {
var _f = _e[_i], contractName = _f[0], contractAddress = _f[1];
const l1Contracts = {};
for (const [contractName, contractAddress] of Object.entries(addresses.l1)) {
l1Contracts[contractName] = (0, exports.getOEContract)(contractName, l2ChainId, {

@@ -162,5 +148,4 @@ address: ((_b = (_a = opts.overrides) === null || _a === void 0 ? void 0 : _a.l1) === null || _b === void 0 ? void 0 : _b[contractName]) || contractAddress,

}
var l2Contracts = {};
for (var _g = 0, _h = Object.entries(addresses.l2); _g < _h.length; _g++) {
var _j = _h[_g], contractName = _j[0], contractAddress = _j[1];
const l2Contracts = {};
for (const [contractName, contractAddress] of Object.entries(addresses.l2)) {
l2Contracts[contractName] = (0, exports.getOEContract)(contractName, l2ChainId, {

@@ -177,5 +162,5 @@ address: ((_d = (_c = opts.overrides) === null || _c === void 0 ? void 0 : _c.l2) === null || _d === void 0 ? void 0 : _d[contractName]) || contractAddress,

exports.getAllOEContracts = getAllOEContracts;
var getBridgeAdapters = function (l2ChainId, messenger, opts) {
const getBridgeAdapters = (l2ChainId, messenger, opts) => {
var _a, _b, _c, _d, _e, _f;
var adapterData = __assign(__assign(__assign({}, (chain_constants_1.CONTRACT_ADDRESSES[l2ChainId] || ((_b = (_a = opts === null || opts === void 0 ? void 0 : opts.contracts) === null || _a === void 0 ? void 0 : _a.l1) === null || _b === void 0 ? void 0 : _b.L1StandardBridge)
const adapterData = Object.assign(Object.assign(Object.assign({}, (chain_constants_1.CONTRACT_ADDRESSES[l2ChainId] || ((_b = (_a = opts === null || opts === void 0 ? void 0 : opts.contracts) === null || _a === void 0 ? void 0 : _a.l1) === null || _b === void 0 ? void 0 : _b.L1StandardBridge)
? {

@@ -196,7 +181,6 @@ Standard: {

: {})), (chain_constants_1.BRIDGE_ADAPTER_DATA[l2ChainId] || {})), ((opts === null || opts === void 0 ? void 0 : opts.overrides) || {}));
var adapters = {};
for (var _i = 0, _g = Object.entries(adapterData); _i < _g.length; _i++) {
var _h = _g[_i], bridgeName = _h[0], bridgeData = _h[1];
const adapters = {};
for (const [bridgeName, bridgeData] of Object.entries(adapterData)) {
adapters[bridgeName] = new bridgeData.Adapter({
messenger: messenger,
messenger,
l1Bridge: bridgeData.l1Bridge,

@@ -203,0 +187,0 @@ l2Bridge: bridgeData.l2Bridge,

115

dist/utils/merkle-utils.js

@@ -25,57 +25,12 @@ "use strict";

};
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 __generator = (this && this.__generator) || function (thisArg, body) {
var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
function verb(n) { return function (v) { return step([n, v]); }; }
function step(op) {
if (f) throw new TypeError("Generator is already executing.");
while (g && (g = 0, op[0] && (_ = 0)), _) try {
if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
if (y = 0, t) op = [op[0] & 2, t.value];
switch (op[0]) {
case 0: case 1: t = op; break;
case 4: _.label++; return { value: op[1], done: false };
case 5: _.label++; y = op[1]; op = [0]; continue;
case 7: op = _.ops.pop(); _.trys.pop(); continue;
default:
if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
if (t[2]) _.ops.pop();
_.trys.pop(); continue;
}
op = body.call(thisArg, _);
} catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
}
};
var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
if (ar || !(i in from)) {
if (!ar) ar = Array.prototype.slice.call(from, 0, i);
ar[i] = from[i];
}
}
return to.concat(ar || Array.prototype.slice.call(from));
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.makeStateTrieProof = exports.maybeAddProofNode = exports.makeMerkleTreeProof = void 0;
var core_utils_1 = require("@eth-optimism/core-utils");
var ethers_1 = require("ethers");
var merkletreejs_1 = require("merkletreejs");
var rlp = __importStar(require("rlp"));
var makeMerkleTreeProof = function (leaves, index) {
var correctedTreeSize = Math.pow(2, Math.ceil(Math.log2(leaves.length)));
var parsedLeaves = [];
for (var i = 0; i < correctedTreeSize; i++) {
const core_utils_1 = require("@eth-optimism/core-utils");
const ethers_1 = require("ethers");
const merkletreejs_1 = require("merkletreejs");
const rlp = __importStar(require("rlp"));
const makeMerkleTreeProof = (leaves, index) => {
const correctedTreeSize = Math.pow(2, Math.ceil(Math.log2(leaves.length)));
const parsedLeaves = [];
for (let i = 0; i < correctedTreeSize; i++) {
if (i < leaves.length) {

@@ -88,7 +43,7 @@ parsedLeaves.push(leaves[i]);

}
var bufLeaves = parsedLeaves.map(core_utils_1.fromHexString);
var tree = new merkletreejs_1.MerkleTree(bufLeaves, function (el) {
const bufLeaves = parsedLeaves.map(core_utils_1.fromHexString);
const tree = new merkletreejs_1.MerkleTree(bufLeaves, (el) => {
return (0, core_utils_1.fromHexString)(ethers_1.ethers.utils.keccak256(el));
});
var proof = tree.getProof(bufLeaves[index], index).map(function (element) {
const proof = tree.getProof(bufLeaves[index], index).map((element) => {
return (0, core_utils_1.toHexString)(element.data);

@@ -99,11 +54,10 @@ });

exports.makeMerkleTreeProof = makeMerkleTreeProof;
var maybeAddProofNode = function (key, proof) {
var modifiedProof = __spreadArray([], proof, true);
var finalProofEl = modifiedProof[modifiedProof.length - 1];
var finalProofElDecoded = rlp.decode(finalProofEl);
const maybeAddProofNode = (key, proof) => {
const modifiedProof = [...proof];
const finalProofEl = modifiedProof[modifiedProof.length - 1];
const finalProofElDecoded = rlp.decode(finalProofEl);
if (finalProofElDecoded.length === 17) {
for (var _i = 0, finalProofElDecoded_1 = finalProofElDecoded; _i < finalProofElDecoded_1.length; _i++) {
var item = finalProofElDecoded_1[_i];
for (const item of finalProofElDecoded) {
if (Array.isArray(item)) {
var suffix = (0, core_utils_1.toHexString)(item[0]).slice(3);
const suffix = (0, core_utils_1.toHexString)(item[0]).slice(3);
if (key.endsWith(suffix)) {

@@ -118,23 +72,16 @@ modifiedProof.push((0, core_utils_1.toHexString)(rlp.encode(item)));

exports.maybeAddProofNode = maybeAddProofNode;
var makeStateTrieProof = function (provider, blockNumber, address, slot) { return __awaiter(void 0, void 0, void 0, function () {
var proof;
return __generator(this, function (_a) {
switch (_a.label) {
case 0: return [4, provider.send('eth_getProof', [
address,
[slot],
(0, core_utils_1.toRpcHexString)(blockNumber),
])];
case 1:
proof = _a.sent();
proof.storageProof[0].proof = (0, exports.maybeAddProofNode)(ethers_1.ethers.utils.keccak256(slot), proof.storageProof[0].proof);
return [2, {
accountProof: proof.accountProof,
storageProof: proof.storageProof[0].proof,
storageValue: ethers_1.BigNumber.from(proof.storageProof[0].value),
storageRoot: proof.storageHash,
}];
}
});
}); };
const makeStateTrieProof = async (provider, blockNumber, address, slot) => {
const proof = await provider.send('eth_getProof', [
address,
[slot],
(0, core_utils_1.toRpcHexString)(blockNumber),
]);
proof.storageProof[0].proof = (0, exports.maybeAddProofNode)(ethers_1.ethers.utils.keccak256(slot), proof.storageProof[0].proof);
return {
accountProof: proof.accountProof,
storageProof: proof.storageProof[0].proof,
storageValue: ethers_1.BigNumber.from(proof.storageProof[0].value),
storageRoot: proof.storageHash,
};
};
exports.makeStateTrieProof = makeStateTrieProof;

36

dist/utils/message-utils.js
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.migratedWithdrawalGasLimit = exports.hashMessageHash = exports.hashLowLevelMessage = void 0;
var core_utils_1 = require("@eth-optimism/core-utils");
var ethers_1 = require("ethers");
var hexDataLength = ethers_1.utils.hexDataLength;
var RELAY_CONSTANT_OVERHEAD = ethers_1.BigNumber.from(200000);
var RELAY_PER_BYTE_DATA_COST = ethers_1.BigNumber.from(16);
var MIN_GAS_DYNAMIC_OVERHEAD_NUMERATOR = ethers_1.BigNumber.from(64);
var MIN_GAS_DYNAMIC_OVERHEAD_DENOMINATOR = ethers_1.BigNumber.from(63);
var RELAY_CALL_OVERHEAD = ethers_1.BigNumber.from(40000);
var RELAY_RESERVED_GAS = ethers_1.BigNumber.from(40000);
var RELAY_GAS_CHECK_BUFFER = ethers_1.BigNumber.from(5000);
var hashLowLevelMessage = function (message) {
const core_utils_1 = require("@eth-optimism/core-utils");
const ethers_1 = require("ethers");
const { hexDataLength } = ethers_1.utils;
const RELAY_CONSTANT_OVERHEAD = ethers_1.BigNumber.from(200000);
const RELAY_PER_BYTE_DATA_COST = ethers_1.BigNumber.from(16);
const MIN_GAS_DYNAMIC_OVERHEAD_NUMERATOR = ethers_1.BigNumber.from(64);
const MIN_GAS_DYNAMIC_OVERHEAD_DENOMINATOR = ethers_1.BigNumber.from(63);
const RELAY_CALL_OVERHEAD = ethers_1.BigNumber.from(40000);
const RELAY_RESERVED_GAS = ethers_1.BigNumber.from(40000);
const RELAY_GAS_CHECK_BUFFER = ethers_1.BigNumber.from(5000);
const hashLowLevelMessage = (message) => {
return (0, core_utils_1.hashWithdrawal)(message.messageNonce, message.sender, message.target, message.value, message.minGasLimit, message.message);
};
exports.hashLowLevelMessage = hashLowLevelMessage;
var hashMessageHash = function (messageHash) {
var data = ethers_1.ethers.utils.defaultAbiCoder.encode(['bytes32', 'uint256'], [messageHash, ethers_1.ethers.constants.HashZero]);
const hashMessageHash = (messageHash) => {
const data = ethers_1.ethers.utils.defaultAbiCoder.encode(['bytes32', 'uint256'], [messageHash, ethers_1.ethers.constants.HashZero]);
return ethers_1.ethers.utils.keccak256(data);
};
exports.hashMessageHash = hashMessageHash;
var migratedWithdrawalGasLimit = function (data, chainID) {
var dataCost = ethers_1.BigNumber.from(hexDataLength(data)).mul(RELAY_PER_BYTE_DATA_COST);
var overhead;
const migratedWithdrawalGasLimit = (data, chainID) => {
const dataCost = ethers_1.BigNumber.from(hexDataLength(data)).mul(RELAY_PER_BYTE_DATA_COST);
let overhead;
if (chainID === 420) {

@@ -30,3 +30,3 @@ overhead = ethers_1.BigNumber.from(200000);

else {
var dynamicOverhead = MIN_GAS_DYNAMIC_OVERHEAD_NUMERATOR.mul(1000000).div(MIN_GAS_DYNAMIC_OVERHEAD_DENOMINATOR);
const dynamicOverhead = MIN_GAS_DYNAMIC_OVERHEAD_NUMERATOR.mul(1000000).div(MIN_GAS_DYNAMIC_OVERHEAD_DENOMINATOR);
overhead = RELAY_CONSTANT_OVERHEAD.add(dynamicOverhead)

@@ -37,3 +37,3 @@ .add(RELAY_CALL_OVERHEAD)

}
var minGasLimit = dataCost.add(overhead);
let minGasLimit = dataCost.add(overhead);
if (minGasLimit.gt(25000000)) {

@@ -40,0 +40,0 @@ minGasLimit = ethers_1.BigNumber.from(25000000);

22

dist/utils/misc-utils.js
"use strict";
var __assign = (this && this.__assign) || function () {
__assign = Object.assign || function(t) {
for (var s, i = 1, n = arguments.length; i < n; i++) {
s = arguments[i];
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
t[p] = s[p];
}
return t;
};
return __assign.apply(this, arguments);
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.omit = void 0;
var omit = function (obj) {
var keys = [];
for (var _i = 1; _i < arguments.length; _i++) {
keys[_i - 1] = arguments[_i];
}
var copy = __assign({}, obj);
for (var _a = 0, keys_1 = keys; _a < keys_1.length; _a++) {
var key = keys_1[_a];
const omit = (obj, ...keys) => {
const copy = Object.assign({}, obj);
for (const key of keys) {
delete copy[key];

@@ -24,0 +8,0 @@ }

2

package.json
{
"name": "@eth-optimism/sdk",
"version": "0.0.0-main-20240610203833",
"version": "0.0.0-main-20240610222650",
"description": "[Optimism] Tools for working with Optimism",

@@ -5,0 +5,0 @@ "main": "dist/index",

dist/cross-chain-messenger.js

Sorry, the diff of this file is too big to display

SocketSocket SOC 2 Logo

Product

  • Package Alerts
  • Integrations
  • Docs
  • Pricing
  • FAQ
  • Roadmap
  • Changelog

About

Packages

npm

Go

Maven

PyPI

Rubygems

Stay in touch

Get open source security insights delivered straight into your inbox.

  • Terms
  • Privacy
  • Security

Made with ⚡️ by Socket Inc