@cenoa/waas-js-sdk
Version:
Official Cenoa Wallet as a Service SDK
141 lines (140 loc) • 6.04 kB
JavaScript
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
};
import { ethers } from 'ethers';
import { diaTokenABI, supportedTokenABI, types } from './config/wallet.config';
import SignManagerTypes from './types';
const SigningType = SignManagerTypes.SigningType;
function getTypes(signCredential) {
if (signCredential.type === SigningType.DEPOSIT) {
return types.depositTypes;
}
if (signCredential.type === SigningType.DEPOSIT_V2) {
return types.depositV2Types;
}
if (signCredential.type === SigningType.WITHDRAW) {
return types.withdrawTypes;
}
if (signCredential.type === SigningType.WITHDRAW_V2) {
return types.withdrawV2Types;
}
if (signCredential.type === SigningType.PERMIT) {
return types.permitTypes;
}
if (signCredential.type === SigningType.TRANSFER) {
return types.transferTypes;
}
if (signCredential.type === SigningType.META_TRANSACTION) {
return types.metaTransactionTypes;
}
if (signCredential.type === SigningType.META_TRANSACTION_V2) {
return types.metaTransactionV2Types;
}
return types.approveTypes;
}
function getEtherWalletAndDomain(wallet, signCredential) {
return __awaiter(this, void 0, void 0, function* () {
// create https provider
const HTTPSProvider = new ethers.JsonRpcProvider(signCredential.url);
// create ether wallet
const etherWallet = new ethers.Wallet(wallet.privateKey, HTTPSProvider);
const chainId = (yield HTTPSProvider.getNetwork()).chainId;
const isPermitType = signCredential.type === SigningType.PERMIT;
if (isPermitType) {
const fiatToken = new ethers.Contract(signCredential.contractAddress, supportedTokenABI, HTTPSProvider);
const [name, address] = yield Promise.all([
fiatToken.name(),
fiatToken.getAddress(),
]);
const domain = {
name,
version: '2',
chainId,
verifyingContract: address,
};
return { etherWallet, domain };
}
const isMetaType = signCredential.type === SigningType.META_TRANSACTION ||
signCredential.type === SigningType.META_TRANSACTION_V2;
if (isMetaType) {
const contract = new ethers.Contract(signCredential.contractAddress, supportedTokenABI, HTTPSProvider);
const [name, address, version] = yield Promise.all([
contract.name(),
contract.getAddress(),
contract.version().catch(() => '1'), // WORKAROUND: some contracts do not have version getter
]);
const domain = {
name,
version,
verifyingContract: address,
};
if (signCredential.type === SigningType.META_TRANSACTION) {
domain.salt = '0x' + chainId.toString(16).padStart(64, '0');
}
else {
// META_TRANSACTION_V2
domain.chainId = chainId;
}
return { etherWallet, domain };
}
const diaToken = new ethers.Contract(signCredential.contractAddress, diaTokenABI, HTTPSProvider);
const [name, version, address] = yield Promise.all([
diaToken.name(),
diaToken.version(),
diaToken.getAddress(),
]);
const domain = {
name,
version,
chainId,
verifyingContract: address,
};
return { etherWallet, domain };
});
}
function signTransaction(wallet, signCredential) {
return __awaiter(this, void 0, void 0, function* () {
const { etherWallet, domain } = yield getEtherWalletAndDomain(wallet, signCredential);
let signature;
let types;
if (signCredential.type === SigningType.SIGN_HASH) {
signature = etherWallet.signingKey.sign(signCredential.payload.hash).serialized;
}
else {
types = getTypes(signCredential);
signature = yield etherWallet.signTypedData(domain, types, signCredential.payload);
}
console.log('[INFO][sign-transaction] signature: ', signature);
const splitSignature = ethers.Signature.from(signature);
if (types) {
const signerAccount = ethers.verifyTypedData(domain, types, signCredential.payload, ethers.Signature.from(splitSignature).serialized);
console.log('[INFO][sign-transaction] signer: ', signerAccount);
}
return {
currency: signCredential.currency,
contractAddress: signCredential.contractAddress,
groupId: signCredential.groupId,
paymentOptions: signCredential.paymentOptions,
request: Object.assign({ type: signCredential.type }, signCredential.payload),
signature: {
v: splitSignature.v,
r: splitSignature.r,
s: splitSignature.s,
signature: signature,
},
};
});
}
var SignManager;
(function (SignManager) {
SignManager.signTransactions = (wallet, signCredentials) => {
return Promise.all(signCredentials.signs.map(signCredential => signTransaction(wallet, signCredential)));
};
})(SignManager || (SignManager = {}));
export default SignManager;