@lucoadam/zebec-wormhole-sdk
Version:
This sdk can be use to transfer assets across chains and to interact with the Zebec's xchain bridge smart contracts for passing message from EVM chain to solana specially to utilize the features of Zebec Streaming and Zebec Multisig Streaming protocol.
940 lines (924 loc) • 46.2 kB
JavaScript
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.ZebecSolBridgeClient = void 0;
var _byteify = require("byteify");
var _keccak = _interopRequireDefault(require("keccak256"));
var _wormholeSdk = require("@certusone/wormhole-sdk");
var anchor = _interopRequireWildcard(require("@project-serum/anchor"));
var _pubkey = require("@project-serum/anchor/dist/cjs/utils/pubkey");
var _splToken = require("@solana/spl-token");
var _web = require("@solana/web3.js");
var _utils = require("../utils");
var _factory = require("./factory");
function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
class ZebecSolBridgeClient {
static ZebecProgramId = new _web.PublicKey(_utils.ZEBEC_ADDRESS);
/**
* Bridge program id of zebec sol bridge client
*/
static BridgeProgramId = new _web.PublicKey(_utils.SOL_ZEBEC_BRIDGE_ADDRESS);
constructor(provider) {
this._provider = provider;
this._bridgeProgram = _factory.ZebecSolBridge__factory.getProgram(ZebecSolBridgeClient.BridgeProgramId, this._provider);
this._zebecProgram = _factory.Zebec__factory.getProgram(ZebecSolBridgeClient.ZebecProgramId, this._provider);
this._transactions = new _factory.ZebecBridgeTransactions(this._bridgeProgram, this._provider);
this._zebecInstructions = new _factory.ZebecInstructions(this._provider);
}
/**
* Gets solana address for xchain user accounts
* @param address xchain user address
* @param chainId source chain id of xchain user
* @deprecated
* This method is to going to be removed soon. Transfer funds from accounts
* created using this methods to other accounts.
* Use `getProxyUserKey` instead.
*/
static getXChainUserKey(address, chainId) {
try {
const senderHash = Buffer.from(address);
const chainIdBuf = Buffer.from(chainId.toString());
const [xChainUser] = (0, _pubkey.findProgramAddressSync)([senderHash, chainIdBuf], new _web.PublicKey(_utils.SOL_ZEBEC_BRIDGE_ADDRESS));
return xChainUser;
} catch (e) {
throw e;
}
}
/**
* Gets proxy solana account for xchain user address
* @param address address of xchain user other than solana
* @param chainId chain id of xchain user
*/
static getProxyUserKey(address, chainId) {
if ((0, _utils.isSolanaChain)(chainId)) {
throw new Error("Chain id is already of solana. Check if you're passing right chain id.");
}
try {
const addressArr = typeof address === "string" ? (0, _wormholeSdk.tryNativeToUint8Array)(address, chainId) : address;
const addressBuf = Buffer.from(addressArr);
const chainIdBuf = Buffer.from((0, _byteify.serializeUint16)(chainId));
return (0, _pubkey.findProgramAddressSync)([addressBuf, chainIdBuf], ZebecSolBridgeClient.BridgeProgramId)[0];
} catch (e) {
throw e;
}
}
/**
* Gets emitter account address for given chain id
* @param chainId source chain id of emitter
* @returns
*/
static getEmitterAccountKey(chainId) {
try {
const [emitterAddress] = (0, _pubkey.findProgramAddressSync)([Buffer.from("EmitterAddress"), (0, _byteify.serializeUint16)(chainId)], this.BridgeProgramId);
return emitterAddress;
} catch (e) {
throw e;
}
}
/**
* Gets process vaa account key
* @param emitterChain source chain id of emitter chain
* @param emitterAddress emitter address
* @param sequence sequence of transaction being emitted
* @returns
*/
static async getProcessVaaKey(emitterChain, emitterAddress, sequence) {
try {
let addressInWormholeHex = await this.parseEmitterAddressHex(emitterChain, emitterAddress);
const [processVaaKey] = (0, _pubkey.findProgramAddressSync)([Buffer.from(addressInWormholeHex, "hex"), (0, _byteify.serializeUint16)(emitterChain), (0, _byteify.serializeUint64)(sequence)], ZebecSolBridgeClient.BridgeProgramId);
return processVaaKey;
} catch (e) {
throw e;
}
}
static async parseEmitterAddressHex(emitterChain, emitterAddress) {
try {
let addressInWormholeHex;
if ((0, _wormholeSdk.isEVMChain)(emitterChain)) {
addressInWormholeHex = (0, _wormholeSdk.getEmitterAddressEth)(emitterAddress);
} else if ((0, _wormholeSdk.isTerraChain)(emitterChain)) {
addressInWormholeHex = await (0, _wormholeSdk.getEmitterAddressTerra)(emitterAddress);
} else {
throw new _utils.NotSupportedError(`ChainId: ${emitterChain} is not supported.`);
}
return addressInWormholeHex;
} catch (e) {
throw e;
}
}
/**
* Gets core bridge vaa account address
* @param timestamp timestamp in vaa
* @param nonce nonce in vaa
* @param emitterChain emitter chain id in vaa
* @param emitterAddress emitter address in vaa
* @param sequence sequence in vaa
* @param consistencyLevel consistency level in vaa
* @param payload payload in vaa
* @returns
*/
static async getCoreBridgeVaaKey(timestamp, nonce, emitterChain, emitterAddress, sequence, consistencyLevel, payload) {
try {
//Create VAA Hash to use in core bridge key
let buffer_array = [];
buffer_array.push((0, _byteify.serializeUint32)(timestamp));
buffer_array.push((0, _byteify.serializeUint32)(nonce));
buffer_array.push((0, _byteify.serializeUint16)(emitterChain));
buffer_array.push(Uint8Array.from(emitterAddress));
buffer_array.push((0, _byteify.serializeUint64)(sequence));
buffer_array.push((0, _byteify.serializeUint8)(consistencyLevel));
buffer_array.push(Uint8Array.from(payload));
const hash = (0, _keccak.default)(Buffer.concat(buffer_array));
// console.log("SOL_BRIDGE_ADDRESS :", SOL_BRIDGE_ADDRESS);
const [coreBridgeVaaKey] = (0, _pubkey.findProgramAddressSync)([Buffer.from("PostedVAA"), hash], new _web.PublicKey("3u8hJUVTA4jH1wYAyUur7FFZVQ8H635K3tSHHF4ssjQ5"));
return coreBridgeVaaKey;
} catch (e) {
throw e;
}
}
/**
* Gets config account address
* @returns
*/
static getConfigAccountKey(programId) {
const [configAddress] = programId ? (0, _pubkey.findProgramAddressSync)([Buffer.from("config")], programId) : (0, _pubkey.findProgramAddressSync)([Buffer.from("config")], this.BridgeProgramId);
return configAddress;
}
async getDataStoragePda(sender, currentCount) {
const [dataStorage] = await _web.PublicKey.findProgramAddress([Buffer.from("data_store"), Buffer.from(sender), Buffer.from([currentCount])], ZebecSolBridgeClient.BridgeProgramId);
return dataStorage;
}
async getTransactionCountKey(addressHash) {
const [count] = await _web.PublicKey.findProgramAddress([Buffer.from("txn_count"), Buffer.from(addressHash)], ZebecSolBridgeClient.BridgeProgramId);
return count;
}
async getCurrentCount(countAccKey) {
let currentCount;
const countAccountInfo = await this._provider.connection.getAccountInfo(countAccKey);
if (!countAccountInfo || !countAccountInfo.data) {
console.log("currentCountInfo is null");
currentCount = 1;
} else {
// console.log("Getting current count info");
let count_info;
count_info = this._bridgeProgram.coder.accounts.decode("Count", countAccountInfo.data);
currentCount = count_info.count + 1;
console.log("current couunt :", currentCount);
}
return currentCount;
}
async sendAndConfirm(signedTxn, blockhash, lastValidBlockHeight) {
(0, _utils.logTransaction)(signedTxn);
const signature = await this._provider.connection.sendRawTransaction(signedTxn.serialize());
await this._provider.connection.confirmTransaction({
signature: signature,
blockhash: blockhash,
lastValidBlockHeight: lastValidBlockHeight
});
return signature;
}
async initialize() {
try {
const config = ZebecSolBridgeClient.getConfigAccountKey();
const systemProgram = anchor.web3.SystemProgram.programId;
const txnId = await this._bridgeProgram.methods.initialize().accounts({
config,
owner: this._provider.wallet.publicKey,
systemProgram
}).rpc();
return txnId;
} catch (e) {
throw e;
}
}
async registerEmitterAddress(emitterAddress, emitterChain) {
try {
const config = ZebecSolBridgeClient.getConfigAccountKey();
const emitterAcc = ZebecSolBridgeClient.getEmitterAccountKey(emitterChain);
const systemProgram = anchor.web3.SystemProgram.programId;
const addressInWormholeHex = await ZebecSolBridgeClient.parseEmitterAddressHex(emitterChain, emitterAddress);
// const emitter_address = tryUint8ArrayToNative(emitterAddress, emitterChain);
// console.log("emitter_address before: ", emitterAcc.toBase58());
console.log("Initiallizeng Address: %s to proxy contract", addressInWormholeHex);
const txnId = await this._bridgeProgram.methods.registerChain(emitterChain, addressInWormholeHex).accounts({
owner: this._provider.wallet.publicKey,
systemProgram,
config,
emitterAcc
}).rpc();
return txnId;
} catch (e) {
throw e;
}
}
async depositToken(vaa, payload) {
console.log("INTO DEPOSIT TOKEN");
(0, _wormholeSdk.setDefaultWasm)("node");
const {
parse_vaa
} = await (0, _wormholeSdk.importCoreWasm)();
const parsedVAA = parse_vaa(vaa);
const chainId = parsedVAA.emitter_chain;
const sender = ZebecSolBridgeClient.getXChainUserKey(payload.sender, chainId);
console.log("Sender: ", sender.toBase58());
const senderHash = payload.sender;
const chainIdBuf = Buffer.from(chainId.toString());
const transactionKeypair = anchor.web3.Keypair.generate();
console.log("transaction account:", transactionKeypair.publicKey.toBase58());
const processVaaKey = await ZebecSolBridgeClient.getProcessVaaKey(parsedVAA.emitter_chain, parsedVAA.emitter_address, parsedVAA.sequence);
console.log("processVaaKey: ", processVaaKey.toBase58());
const emitterAccKey = ZebecSolBridgeClient.getEmitterAccountKey(parsedVAA.emitter_chain);
console.log("emitterAccKey: ", emitterAccKey.toBase58());
const coreBridgeVaaKey = await ZebecSolBridgeClient.getCoreBridgeVaaKey(parsedVAA.timestamp, parsedVAA.nonce, parsedVAA.emitter_chain, parsedVAA.emitter_address, parsedVAA.sequence, parsedVAA.consistency_level, parsedVAA.payload);
console.log("core_bridge: ", coreBridgeVaaKey.toBase58());
console.log("core_bridge info: ", await this._provider.connection.getAccountInfo(coreBridgeVaaKey));
const countAccKey = await this.getTransactionCountKey(senderHash);
console.log("count account:", countAccKey.toBase58());
const currentCount = await this.getCurrentCount(countAccKey);
const dataStorageAccKey = await this.getDataStoragePda(senderHash, currentCount);
console.log("dataStorageAccKey", dataStorageAccKey.toBase58());
const transferAmount = new anchor.BN(payload.amount.toString());
const mint = new _web.PublicKey(payload.tokenMint);
console.log("Token Mint: ", mint.toBase58());
const {
instruction: cpiIxn
} = await this._zebecInstructions.getDepositTokenIxn(sender, mint, transferAmount);
let signatures = [];
try {
let {
transaction: txnStore,
blockhash: bhStore,
lastValidBlockHeight: lbhStore
} = await this._transactions.makeStoreMsg(processVaaKey, emitterAccKey, coreBridgeVaaKey, dataStorageAccKey, countAccKey, currentCount, senderHash);
const storeMsgSig = await this.sendAndConfirm(txnStore, bhStore, lbhStore);
signatures.push(storeMsgSig);
console.log("Your transaction signature for txn1(store_msg) is: ", storeMsgSig);
let {
transaction: txCreateExec,
blockhash: bhCreateExec,
lastValidBlockHeight: lbhCreateExec
} = await this._transactions.makeCreateAndExecDepositTransaction(transactionKeypair, dataStorageAccKey, countAccKey, sender, cpiIxn, senderHash, chainIdBuf);
const create_execSig = await this.sendAndConfirm(txCreateExec, bhCreateExec, lbhCreateExec);
signatures.push(create_execSig);
console.log("Your transaction signature for txn3(exec_tx) is: ", create_execSig);
return {
status: "success",
message: "Deposit Token Success!",
data: {
signatures,
transactionAccount: transactionKeypair.publicKey.toBase58()
}
};
} catch (e) {
console.log(e);
return {
status: "error",
message: e instanceof Error ? e.message : "Unknown Error Occurred!",
data: {
signatures,
transactionAccount: transactionKeypair.publicKey.toBase58()
}
};
}
}
async withdrawDeposit(vaa, payload) {
console.log("INTO WITHDRAW DEPOSIT");
(0, _wormholeSdk.setDefaultWasm)("node");
const {
parse_vaa
} = await (0, _wormholeSdk.importCoreWasm)();
const parsedVAA = parse_vaa(vaa);
console.log("emitter chain", parsedVAA.emitter_chain);
const chainId = parsedVAA.emitter_chain;
const withdrawer = ZebecSolBridgeClient.getXChainUserKey(payload.withdrawer, chainId);
console.log("withdrawer", withdrawer.toBase58());
const withdrawerHash = payload.withdrawer;
const chainIdBuf = Buffer.from(chainId.toString());
const transactionKeypair = anchor.web3.Keypair.generate();
const processVaaKey = await ZebecSolBridgeClient.getProcessVaaKey(parsedVAA.emitter_chain, parsedVAA.emitter_address, parsedVAA.sequence);
console.log("processed vaa key:", processVaaKey.toBase58());
const emitterAccKey = ZebecSolBridgeClient.getEmitterAccountKey(parsedVAA.emitter_chain);
console.log("emitter account:", emitterAccKey.toBase58());
const coreBridgeVaaKey = await ZebecSolBridgeClient.getCoreBridgeVaaKey(parsedVAA.timestamp, parsedVAA.nonce, parsedVAA.emitter_chain, parsedVAA.emitter_address, parsedVAA.sequence, parsedVAA.consistency_level, parsedVAA.payload);
console.log("coreBridgeVaaKey", coreBridgeVaaKey.toBase58());
const countAccKey = await this.getTransactionCountKey(withdrawerHash);
console.log("count account:", countAccKey.toBase58());
const currentCount = await this.getCurrentCount(countAccKey);
console.log("currentCount", currentCount);
const dataStorageAccKey = await this.getDataStoragePda(withdrawerHash, currentCount);
const amount = new anchor.BN(payload.amount.toString());
const mint = new _web.PublicKey(payload.tokenMint);
console.log("token mint:", mint.toBase58());
const {
instruction: cpiIxn
} = await this._zebecInstructions.getWithdrawTokenIxn(withdrawer, mint, amount);
let signatures = [];
try {
let {
transaction: txnStore,
blockhash: bhStore,
lastValidBlockHeight: lbhStore
} = await this._transactions.makeStoreMsg(processVaaKey, emitterAccKey, coreBridgeVaaKey, dataStorageAccKey, countAccKey, currentCount, withdrawerHash);
const storeMsgSig = await this.sendAndConfirm(txnStore, bhStore, lbhStore);
signatures.push(storeMsgSig);
console.log("Your transaction signature for txn1(store_msg) is: ", storeMsgSig);
let {
transaction: txnCreate,
blockhash: bhCreate,
lastValidBlockHeight: lbhCreate
} = await this._transactions.makeCreateWithdrawTransaction(transactionKeypair, dataStorageAccKey, countAccKey, cpiIxn, withdrawerHash);
const createSig = await this.sendAndConfirm(txnCreate, bhCreate, lbhCreate);
signatures.push(createSig);
console.log("Your transaction signature for txn2(create_tx) is: ", createSig);
let {
transaction: txnExec,
blockhash: bhExec,
lastValidBlockHeight: lbhExec
} = await this._transactions.makeExecuteTransaction(transactionKeypair, withdrawer, cpiIxn, withdrawerHash, chainIdBuf);
const execSig = await this.sendAndConfirm(txnExec, bhExec, lbhExec);
signatures.push(execSig);
console.log("Your transaction signature for txn3(exec_tx) is: ", execSig);
return {
status: "success",
message: "Withdraw Deposited Token Success!",
data: {
signatures,
transactionAccount: transactionKeypair.publicKey.toBase58()
}
};
} catch (e) {
console.log(e);
return {
status: "error",
message: e instanceof Error ? e.message : "Unknown Error Occurred!",
data: {
signatures,
transactionAccount: transactionKeypair.publicKey.toBase58()
}
};
}
}
async initializeStream(vaa, payload) {
console.log("INTO INITIALLIZE STREAM");
(0, _wormholeSdk.setDefaultWasm)("node");
const {
parse_vaa
} = await (0, _wormholeSdk.importCoreWasm)();
const parsedVAA = parse_vaa(vaa);
const chainId = parsedVAA.emitter_chain;
const chainIdBuf = Buffer.from(chainId.toString());
const sender = ZebecSolBridgeClient.getXChainUserKey(payload.sender, chainId);
console.log("sender:", sender.toBase58());
const receiver = ZebecSolBridgeClient.getXChainUserKey(payload.recipient, chainId);
console.log("receiver", receiver.toBase58());
const senderHash = payload.sender;
const transactionKeypair = anchor.web3.Keypair.generate();
console.log("transaction key", transactionKeypair.publicKey.toString());
const processVaaKey = await ZebecSolBridgeClient.getProcessVaaKey(parsedVAA.emitter_chain, parsedVAA.emitter_address, parsedVAA.sequence);
console.log("processed vaa account:", processVaaKey.toBase58());
const emitterAccKey = ZebecSolBridgeClient.getEmitterAccountKey(parsedVAA.emitter_chain);
console.log("emitter account:", emitterAccKey.toBase58());
const coreBridgeVaaKey = await ZebecSolBridgeClient.getCoreBridgeVaaKey(parsedVAA.timestamp, parsedVAA.nonce, parsedVAA.emitter_chain, parsedVAA.emitter_address, parsedVAA.sequence, parsedVAA.consistency_level, parsedVAA.payload);
console.log("core bridge vaa account :", coreBridgeVaaKey.toString());
const countAccKey = await this.getTransactionCountKey(senderHash);
console.log("countAccKey: ", countAccKey.toString());
const currentCount = await this.getCurrentCount(countAccKey);
const dataStorageAccKey = await this.getDataStoragePda(senderHash, currentCount);
console.log("dataStorageAccKey:", dataStorageAccKey.toString());
const startTime = new anchor.BN(payload.startTime.toString());
const endTime = new anchor.BN(payload.endTime.toString());
const amount = new anchor.BN(payload.amount.toString());
const canCancel = payload.canCancel.toString() === "1";
const canUpdate = payload.canUpdate.toString() === "1";
const mint = new _web.PublicKey(payload.tokenMint);
console.log("token mint:", mint.toBase58());
const feeReceiver = _utils.fee_keypair.publicKey;
console.log("feeReceiver:", feeReceiver.toBase58());
const {
instruction: cpiIxn,
preInstruction: cpiPreIxn,
signers: cpiSigners
} = await this._zebecInstructions.getInitializeStreamIxn(sender, receiver, mint, feeReceiver, startTime, endTime, amount, canCancel, canUpdate);
if (!cpiPreIxn || !cpiSigners) {
throw new Error("PreInstruction or signers are undefined in initialize stream instruction.");
}
// console.log("Setting Up Fee Vaults:: ");
// await this._zebecProgram.rpc.createFeeAccount(new anchor.BN("25"), {
// accounts: {
// feeVault: feeVaultTemp,
// feeVaultData: feeAccountTemp,
// feeOwner: feeReceiver,
// systemProgram: anchor.web3.SystemProgram.programId,
// rent: anchor.web3.SYSVAR_RENT_PUBKEY,
// },
// signers: [fee_keypair],
// });
let signatures = [];
try {
const {
transaction: txnStore,
blockhash: bhStore,
lastValidBlockHeight: lbhStore
} = await this._transactions.makeStoreMsg(processVaaKey, emitterAccKey, coreBridgeVaaKey, dataStorageAccKey, countAccKey, currentCount, senderHash);
const storeMsgSig = await this.sendAndConfirm(txnStore, bhStore, lbhStore);
signatures.push(storeMsgSig);
console.log("Your transaction signature for txn1(store_msg) is: ", storeMsgSig);
const {
transaction: txnCreate,
blockhash: bhCreate,
lastValidBlockHeight: lbhCreate
} = await this._transactions.makeCreateInitializeStreamTransaction(transactionKeypair, cpiSigners[0], dataStorageAccKey, countAccKey, cpiIxn, cpiPreIxn, senderHash);
const createSig = await this.sendAndConfirm(txnCreate, bhCreate, lbhCreate);
signatures.push(createSig);
console.log("Your transaction signature for txn2(create_tx) is: ", createSig);
const {
transaction: txnExec,
blockhash: bhExec,
lastValidBlockHeight: lbhExec
} = await this._transactions.makeExecuteTransaction(transactionKeypair, sender, cpiIxn, senderHash, chainIdBuf);
const execSig = await this.sendAndConfirm(txnExec, bhExec, lbhExec);
signatures.push(execSig);
console.log("Your transaction signature for txn2 (create_and_exec_start_streanm) is: ", execSig);
return {
status: "success",
message: "Stream started!",
data: {
signatures,
transactionAccount: transactionKeypair.publicKey.toBase58(),
dataAccount: cpiSigners[0].publicKey.toString()
}
};
} catch (e) {
console.log(e);
return {
status: "error",
message: e instanceof Error ? e.message : "Unknown Error Occurred!",
data: {
signatures,
transactionAccount: transactionKeypair.publicKey.toBase58(),
dataAccount: cpiSigners[0].publicKey.toString()
}
};
}
}
async withdrawStreamToken(vaa, payload) {
console.log("INTO WITHDRAW STREAM!!");
(0, _wormholeSdk.setDefaultWasm)("node");
const {
parse_vaa
} = await (0, _wormholeSdk.importCoreWasm)();
const parsedVAA = parse_vaa(vaa);
const chainId = parsedVAA.emitter_chain;
const sender = ZebecSolBridgeClient.getXChainUserKey(payload.sender, chainId);
const receiver = ZebecSolBridgeClient.getXChainUserKey(payload.withdrawer, chainId);
console.log("receiver", receiver.toBase58());
const mint = new _web.PublicKey(payload.tokenMint);
console.log("token mint", mint.toBase58());
const recieverATA = (0, _splToken.getAssociatedTokenAddressSync)(mint, receiver, true);
console.log("recieverATA: ", recieverATA);
const receiverHash = payload.withdrawer;
const chainIdBuf = Buffer.from(chainId.toString());
const transactionKeypair = anchor.web3.Keypair.generate();
const processVaaKey = await ZebecSolBridgeClient.getProcessVaaKey(parsedVAA.emitter_chain, parsedVAA.emitter_address, parsedVAA.sequence);
const emitterAccKey = ZebecSolBridgeClient.getEmitterAccountKey(parsedVAA.emitter_chain);
const coreBridgeVaaKey = await ZebecSolBridgeClient.getCoreBridgeVaaKey(parsedVAA.timestamp, parsedVAA.nonce, parsedVAA.emitter_chain, parsedVAA.emitter_address, parsedVAA.sequence, parsedVAA.consistency_level, parsedVAA.payload);
const countAccKey = await this.getTransactionCountKey(receiverHash);
const currentCount_receiver = await this.getCurrentCount(countAccKey);
console.log("current count receiver:", currentCount_receiver);
const dataStorageAccKey = await this.getDataStoragePda(receiverHash, currentCount_receiver);
const dataAccount = new _web.PublicKey(payload.dataAccount);
console.log("stream escrow account:", dataAccount.toBase58());
const feeReceiver = _utils.fee_keypair.publicKey;
console.log("fee receiver:", feeReceiver.toBase58());
const {
instruction: cpiIxn
} = await this._zebecInstructions.getWithdrawTokenStreamIxn(sender, receiver, dataAccount, mint, feeReceiver);
let signatures = [];
try {
const {
transaction: txnStore,
blockhash: bhStore,
lastValidBlockHeight: lbhStore
} = await this._transactions.makeStoreMsg(processVaaKey, emitterAccKey, coreBridgeVaaKey, dataStorageAccKey, countAccKey, currentCount_receiver, receiverHash);
const storeMsgSig = await this.sendAndConfirm(txnStore, bhStore, lbhStore);
signatures.push(storeMsgSig);
console.log("Your transaction signature for txn1 (store_msg) is: ", storeMsgSig);
const {
transaction: txnCreate,
blockhash: bhCreate,
lastValidBlockHeight: lbhCreate
} = await this._transactions.makeCreateWithrawStreamTransaction(transactionKeypair, dataStorageAccKey, countAccKey, cpiIxn, receiverHash);
const createSig = await this.sendAndConfirm(txnCreate, bhCreate, lbhCreate);
signatures.push(createSig);
console.log("Your transaction signature for txn2 (create_tx) is: ", createSig);
const {
transaction: txnExec,
blockhash: bhExec,
lastValidBlockHeight: lbhExec
} = await this._transactions.makeExecuteTransaction(transactionKeypair, receiver, cpiIxn, receiverHash, chainIdBuf);
const execSig = await this.sendAndConfirm(txnExec, bhExec, lbhExec);
signatures.push(execSig);
console.log("Your transaction signature for txn3 (exec_tx) is: ", execSig);
return {
status: "success",
message: "Withdraw Streamed Token Success!",
data: {
signatures,
transactionAccount: transactionKeypair.publicKey.toBase58()
}
};
} catch (e) {
console.log(e);
return {
status: "error",
message: e instanceof Error ? e.message : "Unknown Error Occurred!",
data: {
signatures,
transactionAccount: transactionKeypair.publicKey.toBase58()
}
};
}
}
async cancelStream(vaa, payload) {
console.log("INTO CANCEL STREAM");
(0, _wormholeSdk.setDefaultWasm)("node");
const {
parse_vaa
} = await (0, _wormholeSdk.importCoreWasm)();
const parsedVAA = parse_vaa(vaa);
const chainId = parsedVAA.emitter_chain;
const chainIdBuf = Buffer.from(chainId.toString());
const sender = ZebecSolBridgeClient.getXChainUserKey(payload.sender, chainId);
const senderHash = payload.sender;
const mint = new _web.PublicKey(payload.tokenMint);
const receiver = ZebecSolBridgeClient.getXChainUserKey(payload.recipient, chainId);
const feeReceiver = _utils.fee_keypair.publicKey;
const dataAccount = new _web.PublicKey(payload.dataAccount);
console.log("stream escrow account:", dataAccount);
const transactionKeypair = anchor.web3.Keypair.generate();
const processVaaKey = await ZebecSolBridgeClient.getProcessVaaKey(parsedVAA.emitter_chain, parsedVAA.emitter_address, parsedVAA.sequence);
console.log("processed vaa account:", processVaaKey.toBase58());
const emitterAccKey = ZebecSolBridgeClient.getEmitterAccountKey(parsedVAA.emitter_chain);
console.log("emitter account:", emitterAccKey.toBase58());
const coreBridgeVaaKey = await ZebecSolBridgeClient.getCoreBridgeVaaKey(parsedVAA.timestamp, parsedVAA.nonce, parsedVAA.emitter_chain, parsedVAA.emitter_address, parsedVAA.sequence, parsedVAA.consistency_level, parsedVAA.payload);
const countAccKey = await this.getTransactionCountKey(senderHash);
const currentCount = await this.getCurrentCount(countAccKey);
const dataStorageAccKey = await this.getDataStoragePda(senderHash, currentCount);
const {
instruction: cpiIxn
} = await this._zebecInstructions.getCancelTokenStreamIxn(sender, receiver, dataAccount, mint, feeReceiver);
let signatures = [];
try {
const {
transaction: txnStore,
blockhash: bhStore,
lastValidBlockHeight: lbhStore
} = await this._transactions.makeStoreMsg(processVaaKey, emitterAccKey, coreBridgeVaaKey, dataStorageAccKey, countAccKey, currentCount, senderHash);
const storeMsgSig = await this.sendAndConfirm(txnStore, bhStore, lbhStore);
signatures.push(storeMsgSig);
console.log("Your transaction signature for txn1(store_msg) is: ", storeMsgSig);
const {
transaction: txnCreate,
blockhash: bhCreate,
lastValidBlockHeight: lbhCreate
} = await this._transactions.makeCreateCancelStreamTransaction(transactionKeypair, dataStorageAccKey, countAccKey, cpiIxn, senderHash);
const createSig = await this.sendAndConfirm(txnCreate, bhCreate, lbhCreate);
signatures.push(createSig);
console.log("Your transaction signature for txn2(create_tx) is: ", createSig);
const {
transaction: txnExec,
blockhash: bhExec,
lastValidBlockHeight: lbhExec
} = await this._transactions.makeExecuteTransaction(transactionKeypair, sender, cpiIxn, senderHash, chainIdBuf);
const execSig = await this.sendAndConfirm(txnExec, bhExec, lbhExec);
signatures.push(execSig);
console.log("Your transaction signature for txn3(exec_tx) is: ", execSig);
return {
status: "success",
message: "Stream Cancelled!",
data: {
signatures,
transactionAccount: transactionKeypair.publicKey.toBase58()
}
};
} catch (e) {
console.log(e);
return {
status: "error",
message: e instanceof Error ? e.message : "Unknown Error Occurred!",
data: {
signatures,
transactionAccount: transactionKeypair.publicKey.toBase58()
}
};
}
}
async pauseResumeStream(vaa, payload) {
console.log("INTO PAUSE STREAM");
(0, _wormholeSdk.setDefaultWasm)("node");
const {
parse_vaa
} = await (0, _wormholeSdk.importCoreWasm)();
const parsedVAA = parse_vaa(vaa);
const chainId = parsedVAA.emitter_chain;
const chainIdBuf = Buffer.from(chainId.toString());
// console.log("from chain id: ", chainId);
const sender = ZebecSolBridgeClient.getXChainUserKey(payload.sender, chainId);
const senderHash = payload.sender;
const receiver = ZebecSolBridgeClient.getXChainUserKey(payload.recipient, chainId);
const mint = new _web.PublicKey(payload.tokenMint);
const dataAccount = new _web.PublicKey(payload.dataAccount);
console.log("stream escrow account:", dataAccount.toString());
const transactionKeypair = anchor.web3.Keypair.generate();
const processVaaKey = await ZebecSolBridgeClient.getProcessVaaKey(parsedVAA.emitter_chain, parsedVAA.emitter_address, parsedVAA.sequence);
console.log("processed vaa account:", processVaaKey.toBase58());
const emitterAccKey = ZebecSolBridgeClient.getEmitterAccountKey(parsedVAA.emitter_chain);
console.log("emitter account:", emitterAccKey.toBase58());
const coreBridgeVaaKey = await ZebecSolBridgeClient.getCoreBridgeVaaKey(parsedVAA.timestamp, parsedVAA.nonce, parsedVAA.emitter_chain, parsedVAA.emitter_address, parsedVAA.sequence, parsedVAA.consistency_level, parsedVAA.payload);
console.log("core bridge account:", coreBridgeVaaKey.toBase58());
const countAccKey = await this.getTransactionCountKey(senderHash);
console.log("count account:", countAccKey.toBase58());
const currentCount = await this.getCurrentCount(countAccKey);
console.log("current count:", currentCount);
const dataStorageAccKey = await this.getDataStoragePda(senderHash, currentCount);
const {
instruction: cpiIxn
} = await this._zebecInstructions.getPauseResumeTokenStreamIxn(sender, receiver, dataAccount, mint);
let signatures = [];
try {
const {
transaction: txnStore,
blockhash: bhStore,
lastValidBlockHeight: lbhStore
} = await this._transactions.makeStoreMsg(processVaaKey, emitterAccKey, coreBridgeVaaKey, dataStorageAccKey, countAccKey, currentCount, senderHash);
const storeMsgSig = await this.sendAndConfirm(txnStore, bhStore, lbhStore);
signatures.push(storeMsgSig);
console.log("Your transaction signature for txn1(store_msg) is: ", storeMsgSig);
const {
transaction: txnCreate,
blockhash: bhCreate,
lastValidBlockHeight: lbhCreate
} = await this._transactions.makePauseResumeStreamTransaction(transactionKeypair, dataStorageAccKey, countAccKey, sender, cpiIxn, senderHash, chainIdBuf);
const create_and_execSig = await this.sendAndConfirm(txnCreate, bhCreate, lbhCreate);
signatures.push(create_and_execSig);
console.log("Your transaction signature for txn2 (create_and_exec_pause/resume) is: ", create_and_execSig);
return {
status: "success",
message: "Stream Paused/Resumed!",
data: {
signatures,
transactionAccount: transactionKeypair.publicKey.toBase58()
}
};
} catch (e) {
console.log(e);
return {
status: "error",
message: e instanceof Error ? e.message : "Unknown Error Occurred!",
data: {
signatures,
transactionAccount: transactionKeypair.publicKey.toBase58()
}
};
}
}
async updateStreamToken(vaa, payload) {
console.log("INTO TOKEN STREAM UPDATE");
(0, _wormholeSdk.setDefaultWasm)("node");
const {
parse_vaa
} = await (0, _wormholeSdk.importCoreWasm)();
const parsedVAA = parse_vaa(vaa);
const chainId = parsedVAA.emitter_chain;
console.log("from chain id: ", chainId);
const chainIdBuf = Buffer.from(chainId.toString());
const sender = ZebecSolBridgeClient.getXChainUserKey(payload.sender, chainId);
const senderHash = payload.sender;
const mint = new _web.PublicKey(payload.tokenMint);
const dataAccount = new _web.PublicKey(payload.dataAccount);
console.log("stream escrow account:", dataAccount.toString());
//** for test only **//
const data_account_info_ = await this._provider.connection.getAccountInfo(dataAccount);
if (data_account_info_) {
const data_account_decode = this._zebecProgram.coder.accounts.decode("StreamToken", data_account_info_.data);
console.log("un_updated_amount: ", data_account_decode.amount.toString());
} else {
console.log("data_account is null");
}
const receiver = ZebecSolBridgeClient.getXChainUserKey(payload.recipient, chainId);
const transactionKeypair = anchor.web3.Keypair.generate();
const processVaaKey = await ZebecSolBridgeClient.getProcessVaaKey(parsedVAA.emitter_chain, parsedVAA.emitter_address, parsedVAA.sequence);
console.log("processed vaa account:", processVaaKey.toBase58());
const emitterAccKey = ZebecSolBridgeClient.getEmitterAccountKey(parsedVAA.emitter_chain);
console.log("emitter account:", emitterAccKey.toBase58());
const coreBridgeVaaKey = await ZebecSolBridgeClient.getCoreBridgeVaaKey(parsedVAA.timestamp, parsedVAA.nonce, parsedVAA.emitter_chain, parsedVAA.emitter_address, parsedVAA.sequence, parsedVAA.consistency_level, parsedVAA.payload);
console.log("core bridge account:", coreBridgeVaaKey.toBase58());
const countAccKey = await this.getTransactionCountKey(senderHash);
console.log("count account:", countAccKey.toBase58());
const startTime = new anchor.BN(payload.startTime.toString());
const endTime = new anchor.BN(payload.endTime.toString());
const amount = new anchor.BN(payload.amount.toString());
const data = this._zebecProgram.coder.instruction.encode("tokenStreamUpdate", {
startTime,
endTime,
amount
});
const currentCount = await this.getCurrentCount(countAccKey);
console.log("current count:", currentCount);
const dataStorageAccKey = await this.getDataStoragePda(senderHash, currentCount);
const {
instruction: cpiTxn
} = await this._zebecInstructions.getTokenStreamUpdateIxn(sender, receiver, dataAccount, mint, startTime, endTime, amount);
let signatures = [];
try {
const {
transaction: txnStore,
blockhash: bhStore,
lastValidBlockHeight: lbhStore
} = await this._transactions.makeStoreMsg(processVaaKey, emitterAccKey, coreBridgeVaaKey, dataStorageAccKey, countAccKey, currentCount, senderHash);
const storeMsgSig = await this.sendAndConfirm(txnStore, bhStore, lbhStore);
signatures.push(storeMsgSig);
console.log("Your transaction signature for txn1 (store_msg) is: ", storeMsgSig);
const {
transaction: txnCreate,
blockhash: bhCreate,
lastValidBlockHeight: lbhCreate
} = await this._transactions.makeUpdateStreamTransaction(transactionKeypair, dataStorageAccKey, countAccKey, sender, cpiTxn, senderHash, chainIdBuf);
const create_and_execSig = await this.sendAndConfirm(txnCreate, bhCreate, lbhCreate);
signatures.push(create_and_execSig);
console.log("Your transaction signature for txn2 (create and exec update stream) is: ", create_and_execSig);
//** for test only **//
const data_account_info = await this._provider.connection.getAccountInfo(dataAccount);
if (data_account_info) {
const data_account_decode = this._zebecProgram.coder.accounts.decode("StreamToken", data_account_info.data);
console.log("updated_amount: ", data_account_decode.amount.toString());
} else {
console.log("data_account is null");
}
return {
status: "success",
message: "Stream Updated!",
data: {
signatures,
transactionAccount: transactionKeypair.publicKey.toBase58()
}
};
} catch (e) {
console.log(e);
return {
status: "error",
message: e instanceof Error ? e.message : "Unknown Error Occurred!",
data: {
signatures,
transactionAccount: transactionKeypair.publicKey.toBase58()
}
};
}
}
async instantTokenTransfer(vaa, payload) {
console.log("INTO INSTANT TOKEN TRANSFER");
(0, _wormholeSdk.setDefaultWasm)("node");
const {
parse_vaa
} = await (0, _wormholeSdk.importCoreWasm)();
const parsedVAA = parse_vaa(vaa);
const chainId = parsedVAA.emitter_chain;
const chainIdBuf = Buffer.from(chainId.toString());
// console.log("from chain id: ", chainId);
const sender = ZebecSolBridgeClient.getXChainUserKey(payload.sender, chainId);
const senderHash = payload.sender;
const receiver = ZebecSolBridgeClient.getXChainUserKey(payload.recipient, chainId);
const mint = new _web.PublicKey(payload.tokenMint);
const transactionKeypair = anchor.web3.Keypair.generate();
const processVaaKey = await ZebecSolBridgeClient.getProcessVaaKey(parsedVAA.emitter_chain, parsedVAA.emitter_address, parsedVAA.sequence);
console.log("processed vaa account:", processVaaKey.toBase58());
const emitterAccKey = ZebecSolBridgeClient.getEmitterAccountKey(parsedVAA.emitter_chain);
console.log("emitter account:", emitterAccKey.toBase58());
const coreBridgeVaaKey = await ZebecSolBridgeClient.getCoreBridgeVaaKey(parsedVAA.timestamp, parsedVAA.nonce, parsedVAA.emitter_chain, parsedVAA.emitter_address, parsedVAA.sequence, parsedVAA.consistency_level, parsedVAA.payload);
console.log("core bridge account:", coreBridgeVaaKey.toBase58());
const countAccKey = await this.getTransactionCountKey(senderHash);
console.log("count account:", countAccKey.toBase58());
const currentCount = await this.getCurrentCount(countAccKey);
console.log("current count:", currentCount);
const dataStorageAccKey = await this.getDataStoragePda(senderHash, currentCount);
const amount = new anchor.BN(payload.amount.toString());
const {
instruction: cpiIxn
} = await this._zebecInstructions.getTokenTransferIxn(sender, receiver, mint, amount);
let signatures = [];
try {
const {
transaction: txnStore,
blockhash: bhStore,
lastValidBlockHeight: lbhStore
} = await this._transactions.makeStoreMsg(processVaaKey, emitterAccKey, coreBridgeVaaKey, dataStorageAccKey, countAccKey, currentCount, senderHash);
const storeMsgSig = await this.sendAndConfirm(txnStore, bhStore, lbhStore);
signatures.push(storeMsgSig);
console.log("Your transaction signature for txn1(store_msg) is: ", storeMsgSig);
const {
transaction: txnCreate,
blockhash: bhCreate,
lastValidBlockHeight: lbhCreate
} = await this._transactions.makeInstantTokenTransferTransaction(transactionKeypair, dataStorageAccKey, countAccKey, cpiIxn, senderHash);
console.log("Transaction LOG create and exec::");
const create_sig = await this.sendAndConfirm(txnCreate, bhCreate, lbhCreate);
signatures.push(create_sig);
console.log("Your transaction signature for txn2 (create_txn) is: ", create_sig);
const {
transaction: txnExec,
blockhash: bhExec,
lastValidBlockHeight: lbhExec
} = await this._transactions.makeExecuteTransaction(transactionKeypair, sender, cpiIxn, senderHash, chainIdBuf);
const exec_sig = await this.sendAndConfirm(txnExec, bhExec, lbhExec);
signatures.push(exec_sig);
console.log("Your transaction signature for txn3(exec_tx) is: ", exec_sig);
return {
status: "success",
message: "Token Transferred.",
data: {
signatures,
transactionAccount: transactionKeypair.publicKey.toBase58()
}
};
} catch (e) {
console.log(e);
return {
status: "error",
message: e instanceof Error ? e.message : "Unknown Error Occurred!",
data: {
signatures,
transactionAccount: transactionKeypair.publicKey.toBase58()
}
};
}
}
async directTokenTransfer(vaa, payload) {
(0, _wormholeSdk.setDefaultWasm)("node");
const {
parse_vaa
} = await (0, _wormholeSdk.importCoreWasm)();
const parsedVAA = parse_vaa(vaa);
const chainId = parsedVAA.emitter_chain;
const chainIdBuf = Buffer.from(chainId.toString());
const sender = ZebecSolBridgeClient.getXChainUserKey(payload.sender, chainId);
const senderHash = payload.sender;
const countAccKey = await this.getTransactionCountKey(senderHash);
const currentCount = await this.getCurrentCount(countAccKey);
const dataStorageAccKey = await this.getDataStoragePda(senderHash, currentCount);
const mint = new _web.PublicKey(payload.tokenMint);
console.log("sender: ", sender);
console.log("sender: ", chainId);
const processVaaKey = await ZebecSolBridgeClient.getProcessVaaKey(parsedVAA.emitter_chain, parsedVAA.emitter_address, parsedVAA.sequence);
const emitterAccKey = ZebecSolBridgeClient.getEmitterAccountKey(parsedVAA.emitter_chain);
const coreBridgeVaaKey = await ZebecSolBridgeClient.getCoreBridgeVaaKey(parsedVAA.timestamp, parsedVAA.nonce, parsedVAA.emitter_chain, parsedVAA.emitter_address, parsedVAA.sequence, parsedVAA.consistency_level, parsedVAA.payload);
console.log("Mint", mint.toBase58());
console.log("sender", sender.toBase58());
const amount = new anchor.BN(payload.amount.toString());
const originalAsset = await (0, _wormholeSdk.getOriginalAssetSol)(this._provider.connection, _utils.SOL_TOKEN_BRIDGE_ADDRESS, mint.toString());
const isWrapped = originalAsset.isWrapped;
console.log("Is Wrapped? ", isWrapped);
//TODO:: Setup fee schedules
const fee = new anchor.BN("1000");
let signatures = [];
try {
const {
transaction: txnStore,
blockhash: bhStore,
lastValidBlockHeight: lbhStore
} = await this._transactions.makeStoreMsg(processVaaKey, emitterAccKey, coreBridgeVaaKey, dataStorageAccKey, countAccKey, currentCount, senderHash);
const storeMsgSig = await this.sendAndConfirm(txnStore, bhStore, lbhStore);
signatures.push(storeMsgSig);
console.log("Your transaction signature for txn1(store_msg) is: ", storeMsgSig);
let txnPayload;
if (!isWrapped) {
txnPayload = await this._transactions.makeDirectTokenTransferTransaction(dataStorageAccKey, countAccKey, sender, mint, senderHash, chainIdBuf, chainId, fee);
} else {
txnPayload = await this._transactions.makeDirectTokenTransferWrappedTransaction(dataStorageAccKey, countAccKey, sender, mint, senderHash, chainIdBuf, chainId, currentCount, fee, Buffer.from(originalAsset.assetAddress), originalAsset.chainId);
}
const transferSig = await this.sendAndConfirm(txnPayload.transaction, txnPayload.blockhash, txnPayload.lastValidBlockHeight);
signatures.push(transferSig);
console.log("Your transaction signature for txn2(transfer_token) is: ", transferSig);
return {
status: "success",
message: "Stream started!",
data: {
signatures
}
};
} catch (e) {
console.log(e);
return {
status: "error",
message: e instanceof Error ? e.message : "Unknown Error Occurred!",
data: {
signatures
}
};
}
}
}
exports.ZebecSolBridgeClient = ZebecSolBridgeClient;
//# sourceMappingURL=client.js.map