endless-luffa-sdk v0.0.9

SDK for Luffa Wallet

Install

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

Usage

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,
});