SDK for Luffa Wallet

Install

``ts
npm install 'endless-luffa-sdk'
npm install 'endless-ts-sdk'
`

Usage

`ts
import {
Network,
EntryFunctionABI,
TypeTagAddress,
TypeTagU128,
AccountAddress,
EndlessConfig,
Endless,
AccountAuthenticator
} from 'endless-ts-sdk'

import {
EndlessLuffaSdk,
UserResponseStatus,
EndlessSignAndSubmitTransactionInput,
EndlessWalletTransactionType,
EndLessSDKEvent,
} from 'endless-luffa-sdk';

const jssdk = new EndlessLuffaSdk({
network: Network.TESTNET,
});

const connectWalletHandler = async () => {
const connectRes = await jssdk.connect();

if (connectRes.status === UserResponseStatus.APPROVED) {
setAccountAddress(connectRes.args.account);
}
};

const disconnectWalletHandler = () => {
jssdk.disconnect().then(() => {
console.log('disconnect success');
});
};

const getAccountHandler = async () => {
const getAccountRes = await jssdk.getAccount();

if (getAccountRes.status === UserResponseStatus.APPROVED) {
console.log('getAccountRes =====>', getAccountRes.args.account);
}
};

const signMessageHandler = async () => {
if (!signMessage || !accountAddress) {
return;
}

const signMessageRes = await jssdk.signMessage({ message: signMessage });

if (signMessageRes.status === UserResponseStatus.APPROVED) {
setSignature(signMessageRes.args.signature.toString());
}
};

const signAndSubmitTrancactionHandler = async () => {
if (!accountAddress) {
alert('please connect wallet');
return;
}

if (!toAccountAddress || !transferAmount) {
alert('please input toAccountAddress and transferAmount');
return;
}

const transferEDSAbi: EntryFunctionABI = {
typeParameters: [],
parameters: [new TypeTagAddress(), new TypeTagU128()],
};

const transferData: EndlessSignAndSubmitTransactionInput = {
payload: {
function: '0x1::endless_account::transfer',
functionArguments: [
AccountAddress.fromBs58String(toAccountAddress),
BigInt(parseInt(transferAmount) * 100000000),
],
abi: transferEDSAbi,
},
};

const transactionRes = await jssdk.signAndSubmitTransaction(transferData);
if (transactionRes.status === UserResponseStatus.APPROVED) {
console.log('signAndSubmitTransaction transactionRes =====>', transactionRes);
}
};

const signTrancactionHandler = async () => {
const config = new EndlessConfig({
network: Network.TESTNET
})
const endless = new Endless(config)
if (!accountAddress) {
alert('please connect wallet');
return;
}

const transferData: EndlessSignAndSubmitTransactionInput = {
payload: {
function: '0x1::endless_account::transfer',
functionArguments: [
AccountAddress.fromBs58String(toAccountAddress),
BigInt(parseInt(transferAmount) * 100000000),
],
abi: transferEDSAbi,
},
};

const txn = await endless.transaction.build.simple({
sender: accountAddress,
data: transferData.payload
});
// EndlessWalletTransactionType.MULTI_AGENT
const transactionRes = await jssdk.signTransaction(txn, EndlessWalletTransactionType.SIMPLE);
if (transactionRes.status === UserResponseStatus.APPROVED) {
console.log('signTransaction transactionRes =====>', transactionRes);
const data = Hex.fromHexString(transactionRes.args.data).toUint8Array();
const deserializer = new Deserializer(data);
const txnRes = AccountAuthenticator.deserialize(deserializer);
console.log('AccountAuthenticator deserializer', txnRes);
}
};

jssdk.onNetworkChange((res) => {
console.log('onNetworkChange res: ', res);
});

jssdk.onAccountChange((accountAddress) => {
if (res.account) {
console.log('onAccountChange res', res);
}
});

jssdk.on(EndLessSDKEvent.CONNECT, (res) => {
console.log('connect', res);
});

jssdk.on(EndLessSDKEvent.DISCONNECT, (res) => {
console.log('disconnect', res);
});

jssdk.on(EndLessSDKEvent.ACCOUNT_CHANGE, (accountAddress) => {
console.log('accountChange', accountAddress);
if (accountAddress.account) {
setAccountAddress(accountAddress.account);
}
});

jssdk.on(EndLessSDKEvent.NETWORK_CHANGE, (networkInfo) => {
console.log('networkInfo', networkInfo);
});

const openHandler = () => {};
jssdk.on(EndLessSDKEvent.OPEN, openHandler);
jssdk.off(EndLessSDKEvent.OPEN, openHandler);

const closeHandler = () => {};
jssdk.on(EndLessSDKEvent.CLOSE, closeHandler);
jssdk.off(EndLessSDKEvent.CLOSE, closeHandler);

jssdk.changeNetwork({
network: Network.MAINNET,
});
``