@0xsplits/splits-sdk
Version:
SDK for the 0xSplits protocol
888 lines • 93.8 kB
JavaScript
"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 = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
return g.next = verb(0), g["throw"] = verb(1), g["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 __read = (this && this.__read) || function (o, n) {
var m = typeof Symbol === "function" && o[Symbol.iterator];
if (!m) return o;
var i = m.call(o), r, ar = [], e;
try {
while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
}
catch (error) { e = { error: error }; }
finally {
try {
if (r && !r.done && (m = i["return"])) m.call(i);
}
finally { if (e) throw e.error; }
}
return ar;
};
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.SplitV1Client = void 0;
var viem_1 = require("viem");
var constants_1 = require("../constants");
var splitMain_1 = require("../constants/abi/splitMain");
var errors_1 = require("../errors");
var utils_1 = require("../utils");
var validation_1 = require("../utils/validation");
var base_1 = require("./base");
var mixin_1 = require("./mixin");
var polygonAbiChainIds = __spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray([
constants_1.ChainId.SEPOLIA,
constants_1.ChainId.HOLESKY
], __read(constants_1.POLYGON_CHAIN_IDS), false), __read(constants_1.OPTIMISM_CHAIN_IDS), false), __read(constants_1.ARBITRUM_CHAIN_IDS), false), __read(constants_1.GNOSIS_CHAIN_IDS), false), __read(constants_1.BSC_CHAIN_IDS), false), __read(constants_1.ZORA_CHAIN_IDS), false), __read(constants_1.BASE_CHAIN_IDS), false), __read(constants_1.BLAST_CHAIN_IDS), false);
var SplitV1Transactions = /** @class */ (function (_super) {
__extends(SplitV1Transactions, _super);
function SplitV1Transactions(transactionClientArgs) {
return _super.call(this, __assign({ supportedChainIds: constants_1.SPLITS_SUPPORTED_CHAIN_IDS }, transactionClientArgs)) || this;
}
SplitV1Transactions.prototype._createSplitTransaction = function (_a) {
return __awaiter(this, arguments, void 0, function (_b) {
var _c, accounts, percentAllocations, distributorFee, functionChainId, result;
var recipients = _b.recipients, distributorFeePercent = _b.distributorFeePercent, _d = _b.controller, controller = _d === void 0 ? viem_1.zeroAddress : _d, chainId = _b.chainId, _e = _b.transactionOverrides, transactionOverrides = _e === void 0 ? {} : _e;
return __generator(this, function (_f) {
switch (_f.label) {
case 0:
(0, validation_1.validateSplitInputs)({ recipients: recipients, distributorFeePercent: distributorFeePercent, controller: controller });
if (this._shouldRequireWalletClient)
this._requireWalletClient();
_c = __read((0, utils_1.getRecipientSortedAddressesAndAllocations)(recipients), 2), accounts = _c[0], percentAllocations = _c[1];
distributorFee = (0, utils_1.getBigIntFromPercent)(distributorFeePercent);
functionChainId = this._getFunctionChainId(chainId);
return [4 /*yield*/, this._executeContractFunction({
contractAddress: (0, constants_1.getSplitMainAddress)(functionChainId),
contractAbi: this._getSplitMainAbi(functionChainId),
functionName: 'createSplit',
functionArgs: [accounts, percentAllocations, distributorFee, controller],
transactionOverrides: transactionOverrides,
})];
case 1:
result = _f.sent();
return [2 /*return*/, result];
}
});
});
};
SplitV1Transactions.prototype._updateSplitTransaction = function (_a) {
return __awaiter(this, arguments, void 0, function (_b) {
var functionChainId, _c, accounts, percentAllocations, distributorFee, result;
var splitAddress = _b.splitAddress, recipients = _b.recipients, distributorFeePercent = _b.distributorFeePercent, chainId = _b.chainId, _d = _b.transactionOverrides, transactionOverrides = _d === void 0 ? {} : _d;
return __generator(this, function (_e) {
switch (_e.label) {
case 0:
(0, validation_1.validateAddress)(splitAddress);
(0, validation_1.validateSplitInputs)({ recipients: recipients, distributorFeePercent: distributorFeePercent });
if (!this._shouldRequireWalletClient) return [3 /*break*/, 2];
this._requireWalletClient();
return [4 /*yield*/, this._requireController(splitAddress)];
case 1:
_e.sent();
_e.label = 2;
case 2:
functionChainId = this._getFunctionChainId(chainId);
_c = __read((0, utils_1.getRecipientSortedAddressesAndAllocations)(recipients), 2), accounts = _c[0], percentAllocations = _c[1];
distributorFee = (0, utils_1.getBigIntFromPercent)(distributorFeePercent);
return [4 /*yield*/, this._executeContractFunction({
contractAddress: (0, constants_1.getSplitMainAddress)(functionChainId),
contractAbi: this._getSplitMainAbi(functionChainId),
functionName: 'updateSplit',
functionArgs: [
splitAddress,
accounts,
percentAllocations,
distributorFee,
],
transactionOverrides: transactionOverrides,
})];
case 3:
result = _e.sent();
return [2 /*return*/, result];
}
});
});
};
SplitV1Transactions.prototype._distributeTokenTransaction = function (_a) {
return __awaiter(this, arguments, void 0, function (_b) {
var distributorPayoutAddress, functionChainId, split, _c, accounts, percentAllocations, distributorFee, result;
var _d;
var splitAddress = _b.splitAddress, token = _b.token, distributorAddress = _b.distributorAddress, chainId = _b.chainId, splitFields = _b.splitFields, _e = _b.transactionOverrides, transactionOverrides = _e === void 0 ? {} : _e;
return __generator(this, function (_f) {
switch (_f.label) {
case 0:
(0, validation_1.validateAddress)(splitAddress);
(0, validation_1.validateAddress)(token);
if (this._shouldRequireWalletClient)
this._requireWalletClient();
distributorPayoutAddress = distributorAddress
? distributorAddress
: ((_d = this._walletClient) === null || _d === void 0 ? void 0 : _d.account)
? this._walletClient.account.address
: viem_1.zeroAddress;
(0, validation_1.validateAddress)(distributorPayoutAddress);
functionChainId = this._getFunctionChainId(chainId);
if (!splitFields) return [3 /*break*/, 1];
split = splitFields;
return [3 /*break*/, 3];
case 1:
this._requireDataClient();
return [4 /*yield*/, this._dataClient.getSplitMetadata({
chainId: functionChainId,
splitAddress: splitAddress,
})];
case 2:
split = _f.sent();
_f.label = 3;
case 3:
_c = __read((0, utils_1.getRecipientSortedAddressesAndAllocations)(split.recipients.map(function (recipient) {
return {
percentAllocation: recipient.percentAllocation,
address: recipient.recipient.address,
};
})), 2), accounts = _c[0], percentAllocations = _c[1];
distributorFee = (0, utils_1.getBigIntFromPercent)(split.distributorFeePercent);
return [4 /*yield*/, this._executeContractFunction({
contractAddress: (0, constants_1.getSplitMainAddress)(functionChainId),
contractAbi: this._getSplitMainAbi(functionChainId),
functionName: token === viem_1.zeroAddress ? 'distributeETH' : 'distributeERC20',
functionArgs: token === viem_1.zeroAddress
? [
splitAddress,
accounts,
percentAllocations,
distributorFee,
distributorPayoutAddress,
]
: [
splitAddress,
token,
accounts,
percentAllocations,
distributorFee,
distributorPayoutAddress,
],
transactionOverrides: transactionOverrides,
})];
case 4:
result = _f.sent();
return [2 /*return*/, result];
}
});
});
};
SplitV1Transactions.prototype._updateSplitAndDistributeTokenTransaction = function (_a) {
return __awaiter(this, arguments, void 0, function (_b) {
var functionChainId, _c, accounts, percentAllocations, distributorFee, distributorPayoutAddress, result;
var _d;
var splitAddress = _b.splitAddress, token = _b.token, recipients = _b.recipients, distributorFeePercent = _b.distributorFeePercent, distributorAddress = _b.distributorAddress, chainId = _b.chainId, _e = _b.transactionOverrides, transactionOverrides = _e === void 0 ? {} : _e;
return __generator(this, function (_f) {
switch (_f.label) {
case 0:
(0, validation_1.validateAddress)(splitAddress);
(0, validation_1.validateAddress)(token);
(0, validation_1.validateSplitInputs)({ recipients: recipients, distributorFeePercent: distributorFeePercent });
if (!this._shouldRequireWalletClient) return [3 /*break*/, 2];
this._requireWalletClient();
return [4 /*yield*/, this._requireController(splitAddress)];
case 1:
_f.sent();
_f.label = 2;
case 2:
functionChainId = this._getFunctionChainId(chainId);
_c = __read((0, utils_1.getRecipientSortedAddressesAndAllocations)(recipients), 2), accounts = _c[0], percentAllocations = _c[1];
distributorFee = (0, utils_1.getBigIntFromPercent)(distributorFeePercent);
distributorPayoutAddress = distributorAddress
? distributorAddress
: ((_d = this._walletClient) === null || _d === void 0 ? void 0 : _d.account)
? this._walletClient.account.address
: viem_1.zeroAddress;
(0, validation_1.validateAddress)(distributorPayoutAddress);
return [4 /*yield*/, this._executeContractFunction({
contractAddress: (0, constants_1.getSplitMainAddress)(functionChainId),
contractAbi: this._getSplitMainAbi(functionChainId),
functionName: token === viem_1.zeroAddress
? 'updateAndDistributeETH'
: 'updateAndDistributeERC20',
functionArgs: token === viem_1.zeroAddress
? [
splitAddress,
accounts,
percentAllocations,
distributorFee,
distributorPayoutAddress,
]
: [
splitAddress,
token,
accounts,
percentAllocations,
distributorFee,
distributorPayoutAddress,
],
transactionOverrides: transactionOverrides,
})];
case 3:
result = _f.sent();
return [2 /*return*/, result];
}
});
});
};
SplitV1Transactions.prototype._withdrawFundsTransaction = function (_a) {
return __awaiter(this, arguments, void 0, function (_b) {
var withdrawEth, erc20s, functionChainId, result;
var address = _b.address, tokens = _b.tokens, chainId = _b.chainId, _c = _b.transactionOverrides, transactionOverrides = _c === void 0 ? {} : _c;
return __generator(this, function (_d) {
switch (_d.label) {
case 0:
(0, validation_1.validateAddress)(address);
if (this._shouldRequireWalletClient)
this._requireWalletClient();
withdrawEth = tokens.includes(viem_1.zeroAddress) ? 1 : 0;
erc20s = tokens.filter(function (token) { return token !== viem_1.zeroAddress; });
functionChainId = this._getFunctionChainId(chainId);
return [4 /*yield*/, this._executeContractFunction({
contractAddress: (0, constants_1.getSplitMainAddress)(functionChainId),
contractAbi: this._getSplitMainAbi(functionChainId),
functionName: 'withdraw',
functionArgs: [address, withdrawEth, erc20s],
transactionOverrides: transactionOverrides,
})];
case 1:
result = _d.sent();
return [2 /*return*/, result];
}
});
});
};
SplitV1Transactions.prototype._initiateControlTransferTransaction = function (_a) {
return __awaiter(this, arguments, void 0, function (_b) {
var functionChainId, result;
var splitAddress = _b.splitAddress, newController = _b.newController, chainId = _b.chainId, _c = _b.transactionOverrides, transactionOverrides = _c === void 0 ? {} : _c;
return __generator(this, function (_d) {
switch (_d.label) {
case 0:
(0, validation_1.validateAddress)(splitAddress);
if (!this._shouldRequireWalletClient) return [3 /*break*/, 2];
this._requireWalletClient();
return [4 /*yield*/, this._requireController(splitAddress)];
case 1:
_d.sent();
_d.label = 2;
case 2:
functionChainId = this._getFunctionChainId(chainId);
return [4 /*yield*/, this._executeContractFunction({
contractAddress: (0, constants_1.getSplitMainAddress)(functionChainId),
contractAbi: this._getSplitMainAbi(functionChainId),
functionName: 'transferControl',
functionArgs: [splitAddress, newController],
transactionOverrides: transactionOverrides,
})];
case 3:
result = _d.sent();
return [2 /*return*/, result];
}
});
});
};
SplitV1Transactions.prototype._cancelControlTransferTransaction = function (_a) {
return __awaiter(this, arguments, void 0, function (_b) {
var functionChainId, result;
var splitAddress = _b.splitAddress, chainId = _b.chainId, _c = _b.transactionOverrides, transactionOverrides = _c === void 0 ? {} : _c;
return __generator(this, function (_d) {
switch (_d.label) {
case 0:
(0, validation_1.validateAddress)(splitAddress);
if (!this._shouldRequireWalletClient) return [3 /*break*/, 2];
this._requireWalletClient();
return [4 /*yield*/, this._requireController(splitAddress)];
case 1:
_d.sent();
_d.label = 2;
case 2:
functionChainId = this._getFunctionChainId(chainId);
return [4 /*yield*/, this._executeContractFunction({
contractAddress: (0, constants_1.getSplitMainAddress)(functionChainId),
contractAbi: this._getSplitMainAbi(functionChainId),
functionName: 'cancelControlTransfer',
functionArgs: [splitAddress],
transactionOverrides: transactionOverrides,
})];
case 3:
result = _d.sent();
return [2 /*return*/, result];
}
});
});
};
SplitV1Transactions.prototype._acceptControlTransferTransaction = function (_a) {
return __awaiter(this, arguments, void 0, function (_b) {
var functionChainId, result;
var splitAddress = _b.splitAddress, chainId = _b.chainId, _c = _b.transactionOverrides, transactionOverrides = _c === void 0 ? {} : _c;
return __generator(this, function (_d) {
switch (_d.label) {
case 0:
(0, validation_1.validateAddress)(splitAddress);
if (!this._shouldRequireWalletClient) return [3 /*break*/, 2];
this._requireWalletClient();
return [4 /*yield*/, this._requireNewPotentialController(splitAddress)];
case 1:
_d.sent();
_d.label = 2;
case 2:
functionChainId = this._getFunctionChainId(chainId);
return [4 /*yield*/, this._executeContractFunction({
contractAddress: (0, constants_1.getSplitMainAddress)(functionChainId),
contractAbi: this._getSplitMainAbi(functionChainId),
functionName: 'acceptControl',
functionArgs: [splitAddress],
transactionOverrides: transactionOverrides,
})];
case 3:
result = _d.sent();
return [2 /*return*/, result];
}
});
});
};
SplitV1Transactions.prototype._makeSplitImmutableTransaction = function (_a) {
return __awaiter(this, arguments, void 0, function (_b) {
var functionChainId, result;
var splitAddress = _b.splitAddress, chainId = _b.chainId, _c = _b.transactionOverrides, transactionOverrides = _c === void 0 ? {} : _c;
return __generator(this, function (_d) {
switch (_d.label) {
case 0:
(0, validation_1.validateAddress)(splitAddress);
if (!this._shouldRequireWalletClient) return [3 /*break*/, 2];
this._requireWalletClient();
return [4 /*yield*/, this._requireController(splitAddress)];
case 1:
_d.sent();
_d.label = 2;
case 2:
functionChainId = this._getFunctionChainId(chainId);
return [4 /*yield*/, this._executeContractFunction({
contractAddress: (0, constants_1.getSplitMainAddress)(functionChainId),
contractAbi: this._getSplitMainAbi(functionChainId),
functionName: 'makeSplitImmutable',
functionArgs: [splitAddress],
transactionOverrides: transactionOverrides,
})];
case 3:
result = _d.sent();
return [2 /*return*/, result];
}
});
});
};
SplitV1Transactions.prototype._batchDistributeAndWithdrawTransaction = function (_a, distributeFunc_1, withdrawFunc_1) {
return __awaiter(this, arguments, void 0, function (_b, distributeFunc, withdrawFunc) {
var distributorPayoutAddress, distributeCalls, withdrawCalls, multicallData, result;
var _this = this;
var _c;
var splitAddress = _b.splitAddress, tokens = _b.tokens, recipientAddresses = _b.recipientAddresses, distributorAddress = _b.distributorAddress;
return __generator(this, function (_d) {
switch (_d.label) {
case 0:
(0, validation_1.validateAddress)(splitAddress);
tokens.map(function (token) { return (0, validation_1.validateAddress)(token); });
recipientAddresses.map(function (address) { return (0, validation_1.validateAddress)(address); });
if (this._shouldRequireWalletClient) {
this._requireWalletClient();
}
distributorPayoutAddress = distributorAddress
? distributorAddress
: ((_c = this._walletClient) === null || _c === void 0 ? void 0 : _c.account)
? this._walletClient.account.address
: viem_1.zeroAddress;
(0, validation_1.validateAddress)(distributorPayoutAddress);
return [4 /*yield*/, Promise.all(tokens.map(function (token) { return __awaiter(_this, void 0, void 0, function () {
return __generator(this, function (_a) {
switch (_a.label) {
case 0: return [4 /*yield*/, distributeFunc({
splitAddress: splitAddress,
token: token,
distributorAddress: distributorPayoutAddress,
})];
case 1: return [2 /*return*/, _a.sent()];
}
});
}); }))];
case 1:
distributeCalls = _d.sent();
return [4 /*yield*/, Promise.all(recipientAddresses.map(function (address) { return __awaiter(_this, void 0, void 0, function () {
return __generator(this, function (_a) {
switch (_a.label) {
case 0: return [4 /*yield*/, withdrawFunc({ address: address, tokens: tokens })];
case 1: return [2 /*return*/, _a.sent()];
}
});
}); }))];
case 2:
withdrawCalls = _d.sent();
multicallData = __spreadArray(__spreadArray([], __read(distributeCalls), false), __read(withdrawCalls), false);
return [4 /*yield*/, this._multicallTransaction({ calls: multicallData })];
case 3:
result = _d.sent();
return [2 /*return*/, result];
}
});
});
};
SplitV1Transactions.prototype._batchDistributeAndWithdrawForAllTransaction = function (_a, distributeFunc_1, withdrawFunc_1) {
return __awaiter(this, arguments, void 0, function (_b, distributeFunc, withdrawFunc) {
var functionChainId, recipients, recipientAddresses, result;
var splitAddress = _b.splitAddress, tokens = _b.tokens, distributorAddress = _b.distributorAddress, chainId = _b.chainId;
return __generator(this, function (_c) {
switch (_c.label) {
case 0:
(0, validation_1.validateAddress)(splitAddress);
tokens.map(function (token) { return (0, validation_1.validateAddress)(token); });
if (this._shouldRequireWalletClient) {
this._requireWalletClient();
}
this._requireDataClient();
functionChainId = this._getFunctionChainId(chainId);
return [4 /*yield*/, this._dataClient.getSplitMetadata({
chainId: functionChainId,
splitAddress: splitAddress,
})];
case 1:
recipients = (_c.sent()).recipients;
recipientAddresses = recipients.map(function (recipient) { return recipient.recipient.address; });
return [4 /*yield*/, this._batchDistributeAndWithdrawTransaction({
splitAddress: splitAddress,
tokens: tokens,
recipientAddresses: recipientAddresses,
distributorAddress: distributorAddress,
}, distributeFunc, withdrawFunc)];
case 2:
result = _c.sent();
return [2 /*return*/, result];
}
});
});
};
SplitV1Transactions.prototype._checkForSplitExistence = function (_a) {
return __awaiter(this, arguments, void 0, function (_b) {
var formattedSplitAddress, splitMainContract, splitHash;
var splitAddress = _b.splitAddress, chainId = _b.chainId;
return __generator(this, function (_c) {
switch (_c.label) {
case 0:
formattedSplitAddress = (0, viem_1.getAddress)(splitAddress);
splitMainContract = this._getSplitMainContract(chainId);
return [4 /*yield*/, splitMainContract.read.getHash([
formattedSplitAddress,
])];
case 1:
splitHash = _c.sent();
if (splitHash ===
'0x0000000000000000000000000000000000000000000000000000000000000000') {
// Split does not exist
throw new errors_1.AccountNotFoundError('Split', formattedSplitAddress, chainId);
}
return [2 /*return*/];
}
});
});
};
SplitV1Transactions.prototype._getSplitMetadataViaProvider = function (_a) {
return __awaiter(this, arguments, void 0, function (_b) {
var formattedSplitAddress, publicClient, _c, blockRange, createLog, updateLog, split;
var splitAddress = _b.splitAddress, chainId = _b.chainId, cachedData = _b.cachedData;
return __generator(this, function (_d) {
switch (_d.label) {
case 0:
if (chainId === constants_1.ChainId.MAINNET)
throw new Error('Mainnet not supported for provider metadata');
formattedSplitAddress = (0, viem_1.getAddress)(splitAddress);
publicClient = this._getPublicClient(chainId);
return [4 /*yield*/, this._checkForSplitExistence({ splitAddress: splitAddress, chainId: chainId })];
case 1:
_d.sent();
return [4 /*yield*/, (0, utils_1.getSplitCreateAndUpdateLogs)({
splitAddress: splitAddress,
publicClient: publicClient,
splitCreatedEvent: constants_1.splitV1CreatedEvent,
splitUpdatedEvent: constants_1.splitV1UpdatedEvent,
addresses: [(0, constants_1.getSplitMainAddress)(chainId)],
startBlockNumber: (0, constants_1.getSplitV1StartBlock)(chainId),
cachedBlocks: cachedData === null || cachedData === void 0 ? void 0 : cachedData.blocks,
defaultBlockRange: cachedData === null || cachedData === void 0 ? void 0 : cachedData.blockRange,
})];
case 2:
_c = _d.sent(), blockRange = _c.blockRange, createLog = _c.createLog, updateLog = _c.updateLog;
if (!createLog)
throw new errors_1.AccountNotFoundError('Split', formattedSplitAddress, publicClient.chain.id);
return [4 /*yield*/, this._buildSplitFromLogs({
splitAddress: formattedSplitAddress,
chainId: chainId,
createLog: createLog,
updateLog: updateLog ? updateLog : undefined,
})];
case 3:
split = _d.sent();
return [2 /*return*/, { split: split, blockRange: blockRange }];
}
});
});
};
SplitV1Transactions.prototype._buildSplitFromLogs = function (_a) {
return __awaiter(this, arguments, void 0, function (_b) {
var splitMainContract, controller, recipients, split, updatedRecipients;
var splitAddress = _b.splitAddress, chainId = _b.chainId, createLog = _b.createLog, updateLog = _b.updateLog;
return __generator(this, function (_c) {
switch (_c.label) {
case 0:
splitMainContract = this._getSplitMainContract(chainId);
return [4 /*yield*/, splitMainContract.read.getController([
(0, viem_1.getAddress)(splitAddress),
])];
case 1:
controller = _c.sent();
recipients = createLog.args.accounts.map(function (recipient, i) {
return {
recipient: {
address: recipient,
},
ownership: BigInt(createLog.args.percentAllocations[i]),
percentAllocation: (0, utils_1.fromBigIntToPercent)(BigInt(createLog.args.percentAllocations[i]), BigInt(1000000)),
};
});
split = {
address: splitAddress,
totalOwnership: BigInt(1000000),
recipients: recipients,
distributorFeePercent: (0, utils_1.fromBigIntToPercent)(BigInt(createLog.args.distributorFee)),
distributeDirection: 'pull',
type: 'Split',
controller: {
address: controller,
},
distributionsPaused: false,
newPotentialController: {
address: viem_1.zeroAddress,
},
createdBlock: Number(createLog.blockNumber),
updateBlock: Number(createLog.blockNumber),
};
if (!updateLog)
return [2 /*return*/, split];
updatedRecipients = updateLog.args.accounts.map(function (recipient, i) {
return {
recipient: {
address: recipient,
},
ownership: BigInt(updateLog.args.percentAllocations[i]),
percentAllocation: (0, utils_1.fromBigIntToPercent)(BigInt(updateLog.args.percentAllocations[i]), BigInt(1000000)),
};
});
split.recipients = updatedRecipients;
split.distributorFeePercent = (0, utils_1.fromBigIntToPercent)(BigInt(updateLog.args.distributorFee));
split.updateBlock = Number(updateLog.blockNumber);
return [2 /*return*/, split];
}
});
});
};
SplitV1Transactions.prototype._requireController = function (splitAddress) {
return __awaiter(this, void 0, void 0, function () {
var chainId, splitMainContract, controller, walletAddress;
var _a;
return __generator(this, function (_b) {
switch (_b.label) {
case 0:
chainId = this._walletClient.chain.id;
splitMainContract = this._getSplitMainContract(chainId);
return [4 /*yield*/, splitMainContract.read.getController([
(0, viem_1.getAddress)(splitAddress),
])];
case 1:
controller = _b.sent();
walletAddress = (_a = this._walletClient.account) === null || _a === void 0 ? void 0 : _a.address;
if (controller.toLowerCase() !== (walletAddress === null || walletAddress === void 0 ? void 0 : walletAddress.toLowerCase()))
throw new errors_1.InvalidAuthError("Action only available to the split controller. Split id: ".concat(splitAddress, ", split controller: ").concat(controller, ", wallet address: ").concat(walletAddress));
return [2 /*return*/];
}
});
});
};
SplitV1Transactions.prototype._requireNewPotentialController = function (splitAddress) {
return __awaiter(this, void 0, void 0, function () {
var chainId, splitMainContract, newPotentialController, walletAddress;
var _a;
return __generator(this, function (_b) {
switch (_b.label) {
case 0:
chainId = this._walletClient.chain.id;
splitMainContract = this._getSplitMainContract(chainId);
return [4 /*yield*/, splitMainContract.read.getNewPotentialController([
(0, viem_1.getAddress)(splitAddress),
])];
case 1:
newPotentialController = _b.sent();
walletAddress = (_a = this._walletClient.account) === null || _a === void 0 ? void 0 : _a.address;
if (newPotentialController.toLowerCase() !== (walletAddress === null || walletAddress === void 0 ? void 0 : walletAddress.toLowerCase()))
throw new errors_1.InvalidAuthError("Action only available to the split's new potential controller. Split new potential controller: ".concat(newPotentialController, ". Wallet address: ").concat(walletAddress));
return [2 /*return*/];
}
});
});
};
SplitV1Transactions.prototype._getSplitMainContract = function (chainId) {
var publicClient = this._getPublicClient(chainId);
return (0, viem_1.getContract)({
address: (0, constants_1.getSplitMainAddress)(chainId),
abi: splitMain_1.splitMainEthereumAbi,
client: publicClient,
});
};
SplitV1Transactions.prototype._getSplitMainAbi = function (chainId) {
if (constants_1.ETHEREUM_CHAIN_IDS.includes(chainId)) {
return splitMain_1.splitMainEthereumAbi;
}
else if (polygonAbiChainIds.includes(chainId)) {
return splitMain_1.splitMainPolygonAbi;
}
else
throw new errors_1.UnsupportedChainIdError(chainId, constants_1.SPLITS_SUPPORTED_CHAIN_IDS);
};
return SplitV1Transactions;
}(base_1.BaseTransactions));
// eslint-disable-next-line @typescript-eslint/no-unsafe-declaration-merging
var SplitV1Client = /** @class */ (function (_super) {
__extends(SplitV1Client, _super);
function SplitV1Client(clientArgs) {
var _this = _super.call(this, __assign({ transactionType: constants_1.TransactionType.Transaction }, clientArgs)) || this;
_this.callData = new SplitV1CallData(clientArgs);
_this.estimateGas = new SplitV1GasEstimates(clientArgs);
return _this;
}
SplitV1Client.prototype.getEventTopics = function (chainId) {
var splitMainAbi = this._getSplitMainAbi(chainId);
return {
createSplit: [
(0, viem_1.encodeEventTopics)({
abi: splitMainAbi,
eventName: 'CreateSplit',
})[0],
],
updateSplit: [
(0, viem_1.encodeEventTopics)({
abi: splitMainAbi,
eventName: 'UpdateSplit',
})[0],
],
distributeToken: [
(0, viem_1.encodeEventTopics)({
abi: splitMainAbi,
eventName: 'DistributeETH',
})[0],
(0, viem_1.encodeEventTopics)({
abi: splitMainAbi,
eventName: 'DistributeERC20',
})[0],
],
updateSplitAndDistributeToken: [
(0, viem_1.encodeEventTopics)({
abi: splitMainAbi,
eventName: 'UpdateSplit',
})[0],
(0, viem_1.encodeEventTopics)({
abi: splitMainAbi,
eventName: 'DistributeETH',
})[0],
(0, viem_1.encodeEventTopics)({
abi: splitMainAbi,
eventName: 'DistributeERC20',
})[0],
],
withdrawFunds: [
(0, viem_1.encodeEventTopics)({
abi: splitMainAbi,
eventName: 'Withdrawal',
})[0],
],
initiateControlTransfer: [
(0, viem_1.encodeEventTopics)({
abi: splitMainAbi,
eventName: 'InitiateControlTransfer',
})[0],
],
cancelControlTransfer: [
(0, viem_1.encodeEventTopics)({
abi: splitMainAbi,
eventName: 'CancelControlTransfer',
})[0],
],
acceptControlTransfer: [
(0, viem_1.encodeEventTopics)({
abi: splitMainAbi,
eventName: 'ControlTransfer',
})[0],
],
makeSplitImmutable: [
(0, viem_1.encodeEventTopics)({
abi: splitMainAbi,
eventName: 'ControlTransfer',
})[0],
],
};
};
/*
/
/ SPLIT ACTIONS
/
*/
// Write actions
SplitV1Client.prototype._submitCreateSplitTransaction = function (createSplitArgs) {
return __awaiter(this, void 0, void 0, function () {
var txHash;
return __generator(this, function (_a) {
switch (_a.label) {
case 0: return [4 /*yield*/, this._createSplitTransaction(createSplitArgs)];
case 1:
txHash = _a.sent();
if (!this._isContractTransaction(txHash))
throw new Error('Invalid response');
return [2 /*return*/, { txHash: txHash }];
}
});
});
};
SplitV1Client.prototype.createSplit = function (createSplitArgs) {
return __awaiter(this, void 0, void 0, function () {
var txHash, functionChainId, eventTopics, events, event, log, log;
return __generator(this, function (_a) {
switch (_a.label) {
case 0: return [4 /*yield*/, this._submitCreateSplitTransaction(createSplitArgs)];
case 1:
txHash = (_a.sent()).txHash;
functionChainId = this._getFunctionChainId(createSplitArgs.chainId);
eventTopics = this.getEventTopics(this._getFunctionChainId(functionChainId));
return [4 /*yield*/, this.getTransactionEvents({
txHash: txHash,
eventTopics: eventTopics.createSplit,
})];
case 2:
events = _a.sent();
event = events.length > 0 ? events[0] : undefined;
if (event) {
if (constants_1.ETHEREUM_CHAIN_IDS.includes(functionChainId)) {
log = (0, viem_1.decodeEventLog)({
abi: splitMain_1.splitMainEthereumAbi,
data: event.data,
topics: event.topics,
});
if (log.eventName !== 'CreateSplit')
throw new Error();
return [2 /*return*/, {
splitAddress: log.args.split,
event: event,
}];
}
else {
log = (0, viem_1.decodeEventLog)({
abi: splitMain_1.splitMainPolygonAbi,
data: event.data,
topics: event.topics,
});
if (log.eventName !== 'CreateSplit')
throw new Error();
return [2 /*return*/, {
splitAddress: log.args.split,
event: event,
}];
}
}
throw new errors_1.TransactionFailedError();
}
});
});
};
SplitV1Client.prototype._submitUpdateSplitTransaction = function (updateSplitArgs) {
return __awaiter(this, void 0, void 0, function () {
var txHash;
return __generator(this, function (_a) {
switch (_a.label) {
case 0: return [4 /*yield*/, this._updateSplitTransaction(updateSplitArgs)];
case 1:
txHash = _a.sent();
if (!this._isContractTransaction(txHash))
throw new Error('Invalid response');
return [2 /*return*/, { txHash: txHash }];
}
});
});
};
SplitV1Client.prototype.updateSplit = function (updateSplitArgs) {
return __awaiter(this, void 0, vo